Move webrtc/{base => rtc_base}

webrtc/base/testutils.h

Index: webrtc/base/testutils.h
diff --git a/webrtc/base/testutils.h b/webrtc/base/testutils.h
index cda7a8457e73064353919bfdb0efc77e19a3fbe5..74f216066ee789a69e0fbfcb722a840b6fe216b9 100644
--- a/webrtc/base/testutils.h
+++ b/webrtc/base/testutils.h
@@ -8,559 +8,12 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#ifndef WEBRTC_BASE_TESTUTILS_H__
-#define WEBRTC_BASE_TESTUTILS_H__
+#ifndef WEBRTC_BASE_TESTUTILS_H_
+#define WEBRTC_BASE_TESTUTILS_H_
 
-// Utilities for testing rtc infrastructure in unittests
 
-#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
-#include <X11/Xlib.h>
-#include <X11/extensions/Xrandr.h>
+// This header is deprecated and is just left here temporarily during
+// refactoring. See https://bugs.webrtc.org/7634 for more details.
+#include "webrtc/rtc_base/testutils.h"
 
-// X defines a few macros that stomp on types that gunit.h uses.
-#undef None
-#undef Bool
-#endif
-
-#include <algorithm>
-#include <map>
-#include <memory>
-#include <vector>
-#include "webrtc/base/arraysize.h"
-#include "webrtc/base/asyncsocket.h"
-#include "webrtc/base/checks.h"
-#include "webrtc/base/gunit.h"
-#include "webrtc/base/nethelpers.h"
-#include "webrtc/base/pathutils.h"
-#include "webrtc/base/stream.h"
-#include "webrtc/base/stringencode.h"
-#include "webrtc/base/stringutils.h"
-#include "webrtc/base/thread.h"
-
-namespace webrtc {
-namespace testing {
-
-using namespace rtc;
-
-///////////////////////////////////////////////////////////////////////////////
-// StreamSink - Monitor asynchronously signalled events from StreamInterface
-// or AsyncSocket (which should probably be a StreamInterface.
-///////////////////////////////////////////////////////////////////////////////
-
-// Note: Any event that is an error is treaded as SSE_ERROR instead of that
-// event.
-
-enum StreamSinkEvent {
-  SSE_OPEN  = SE_OPEN,
-  SSE_READ  = SE_READ,
-  SSE_WRITE = SE_WRITE,
-  SSE_CLOSE = SE_CLOSE,
-  SSE_ERROR = 16
-};
-
-class StreamSink : public sigslot::has_slots<> {
- public:
-  void Monitor(StreamInterface* stream) {
-   stream->SignalEvent.connect(this, &StreamSink::OnEvent);
-   events_.erase(stream);
-  }
-  void Unmonitor(StreamInterface* stream) {
-   stream->SignalEvent.disconnect(this);
-   // In case you forgot to unmonitor a previous object with this address
-   events_.erase(stream);
-  }
-  bool Check(StreamInterface* stream, StreamSinkEvent event, bool reset = true) {
-    return DoCheck(stream, event, reset);
-  }
-  int Events(StreamInterface* stream, bool reset = true) {
-    return DoEvents(stream, reset);
-  }
-
-  void Monitor(AsyncSocket* socket) {
-   socket->SignalConnectEvent.connect(this, &StreamSink::OnConnectEvent);
-   socket->SignalReadEvent.connect(this, &StreamSink::OnReadEvent);
-   socket->SignalWriteEvent.connect(this, &StreamSink::OnWriteEvent);
-   socket->SignalCloseEvent.connect(this, &StreamSink::OnCloseEvent);
-   // In case you forgot to unmonitor a previous object with this address
-   events_.erase(socket);
-  }
-  void Unmonitor(AsyncSocket* socket) {
-   socket->SignalConnectEvent.disconnect(this);
-   socket->SignalReadEvent.disconnect(this);
-   socket->SignalWriteEvent.disconnect(this);
-   socket->SignalCloseEvent.disconnect(this);
-   events_.erase(socket);
-  }
-  bool Check(AsyncSocket* socket, StreamSinkEvent event, bool reset = true) {
-    return DoCheck(socket, event, reset);
-  }
-  int Events(AsyncSocket* socket, bool reset = true) {
-    return DoEvents(socket, reset);
-  }
-
- private:
-  typedef std::map<void*,int> EventMap;
-
-  void OnEvent(StreamInterface* stream, int events, int error) {
-    if (error) {
-      events = SSE_ERROR;
-    }
-    AddEvents(stream, events);
-  }
-  void OnConnectEvent(AsyncSocket* socket) {
-    AddEvents(socket, SSE_OPEN);
-  }
-  void OnReadEvent(AsyncSocket* socket) {
-    AddEvents(socket, SSE_READ);
-  }
-  void OnWriteEvent(AsyncSocket* socket) {
-    AddEvents(socket, SSE_WRITE);
-  }
-  void OnCloseEvent(AsyncSocket* socket, int error) {
-    AddEvents(socket, (0 == error) ? SSE_CLOSE : SSE_ERROR);
-  }
-
-  void AddEvents(void* obj, int events) {
-    EventMap::iterator it = events_.find(obj);
-    if (events_.end() == it) {
-      events_.insert(EventMap::value_type(obj, events));
-    } else {
-      it->second |= events;
-    }
-  }
-  bool DoCheck(void* obj, StreamSinkEvent event, bool reset) {
-    EventMap::iterator it = events_.find(obj);
-    if ((events_.end() == it) || (0 == (it->second & event))) {
-      return false;
-    }
-    if (reset) {
-      it->second &= ~event;
-    }
-    return true;
-  }
-  int DoEvents(void* obj, bool reset) {
-    EventMap::iterator it = events_.find(obj);
-    if (events_.end() == it)
-      return 0;
-    int events = it->second;
-    if (reset) {
-      it->second = 0;
-    }
-    return events;
-  }
-
-  EventMap events_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// StreamSource - Implements stream interface and simulates asynchronous
-// events on the stream, without a network.  Also buffers written data.
-///////////////////////////////////////////////////////////////////////////////
-
-class StreamSource : public StreamInterface {
-public:
-  StreamSource() {
-    Clear();
-  }
-
-  void Clear() {
-    readable_data_.clear();
-    written_data_.clear();
-    state_ = SS_CLOSED;
-    read_block_ = 0;
-    write_block_ = SIZE_UNKNOWN;
-  }
-  void QueueString(const char* data) {
-    QueueData(data, strlen(data));
-  }
-  void QueueStringF(const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    char buffer[1024];
-    size_t len = vsprintfn(buffer, sizeof(buffer), format, args);
-    RTC_CHECK(len < sizeof(buffer) - 1);
-    va_end(args);
-    QueueData(buffer, len);
-  }
-  void QueueData(const char* data, size_t len) {
-    readable_data_.insert(readable_data_.end(), data, data + len);
-    if ((SS_OPEN == state_) && (readable_data_.size() == len)) {
-      SignalEvent(this, SE_READ, 0);
-    }
-  }
-  std::string ReadData() {
-    std::string data;
-    // avoid accessing written_data_[0] if it is undefined
-    if (written_data_.size() > 0) {
-      data.insert(0, &written_data_[0], written_data_.size());
-    }
-    written_data_.clear();
-    return data;
-  }
-  void SetState(StreamState state) {
-    int events = 0;
-    if ((SS_OPENING == state_) && (SS_OPEN == state)) {
-      events |= SE_OPEN;
-      if (!readable_data_.empty()) {
-        events |= SE_READ;
-      }
-    } else if ((SS_CLOSED != state_) && (SS_CLOSED == state)) {
-      events |= SE_CLOSE;
-    }
-    state_ = state;
-    if (events) {
-      SignalEvent(this, events, 0);
-    }
-  }
-  // Will cause Read to block when there are pos bytes in the read queue.
-  void SetReadBlock(size_t pos) { read_block_ = pos; }
-  // Will cause Write to block when there are pos bytes in the write queue.
-  void SetWriteBlock(size_t pos) { write_block_ = pos; }
-
-  virtual StreamState GetState() const { return state_; }
-  virtual StreamResult Read(void* buffer, size_t buffer_len,
-                            size_t* read, int* error) {
-    if (SS_CLOSED == state_) {
-      if (error) *error = -1;
-      return SR_ERROR;
-    }
-    if ((SS_OPENING == state_) || (readable_data_.size() <= read_block_)) {
-      return SR_BLOCK;
-    }
-    size_t count = std::min(buffer_len, readable_data_.size() - read_block_);
-    memcpy(buffer, &readable_data_[0], count);
-    size_t new_size = readable_data_.size() - count;
-    // Avoid undefined access beyond the last element of the vector.
-    // This only happens when new_size is 0.
-    if (count < readable_data_.size()) {
-      memmove(&readable_data_[0], &readable_data_[count], new_size);
-    }
-    readable_data_.resize(new_size);
-    if (read) *read = count;
-    return SR_SUCCESS;
-  }
-  virtual StreamResult Write(const void* data, size_t data_len,
-                             size_t* written, int* error) {
-    if (SS_CLOSED == state_) {
-      if (error) *error = -1;
-      return SR_ERROR;
-    }
-    if (SS_OPENING == state_) {
-      return SR_BLOCK;
-    }
-    if (SIZE_UNKNOWN != write_block_) {
-      if (written_data_.size() >= write_block_) {
-        return SR_BLOCK;
-      }
-      if (data_len > (write_block_ - written_data_.size())) {
-        data_len = write_block_ - written_data_.size();
-      }
-    }
-    if (written) *written = data_len;
-    const char* cdata = static_cast<const char*>(data);
-    written_data_.insert(written_data_.end(), cdata, cdata + data_len);
-    return SR_SUCCESS;
-  }
-  virtual void Close() { state_ = SS_CLOSED; }
-
-private:
-  typedef std::vector<char> Buffer;
-  Buffer readable_data_, written_data_;
-  StreamState state_;
-  size_t read_block_, write_block_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// SocketTestClient
-// Creates a simulated client for testing.  Works on real and virtual networks.
-///////////////////////////////////////////////////////////////////////////////
-
-class SocketTestClient : public sigslot::has_slots<> {
-public:
- SocketTestClient() { Init(nullptr, AF_INET); }
- SocketTestClient(AsyncSocket* socket) {
-   Init(socket, socket->GetLocalAddress().family());
-  }
-  SocketTestClient(const SocketAddress& address) {
-    Init(nullptr, address.family());
-    socket_->Connect(address);
-  }
-
-  AsyncSocket* socket() { return socket_.get(); }
-
-  void QueueString(const char* data) {
-    QueueData(data, strlen(data));
-  }
-  void QueueStringF(const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    char buffer[1024];
-    size_t len = vsprintfn(buffer, sizeof(buffer), format, args);
-    RTC_CHECK(len < sizeof(buffer) - 1);
-    va_end(args);
-    QueueData(buffer, len);
-  }
-  void QueueData(const char* data, size_t len) {
-    send_buffer_.insert(send_buffer_.end(), data, data + len);
-    if (Socket::CS_CONNECTED == socket_->GetState()) {
-      Flush();
-    }
-  }
-  std::string ReadData() {
-    std::string data(&recv_buffer_[0], recv_buffer_.size());
-    recv_buffer_.clear();
-    return data;
-  }
-
-  bool IsConnected() const {
-    return (Socket::CS_CONNECTED == socket_->GetState());
-  }
-  bool IsClosed() const {
-    return (Socket::CS_CLOSED == socket_->GetState());
-  }
-
-private:
-  typedef std::vector<char> Buffer;
-
-  void Init(AsyncSocket* socket, int family) {
-    if (!socket) {
-      socket = Thread::Current()->socketserver()
-          ->CreateAsyncSocket(family, SOCK_STREAM);
-    }
-    socket_.reset(socket);
-    socket_->SignalConnectEvent.connect(this,
-      &SocketTestClient::OnConnectEvent);
-    socket_->SignalReadEvent.connect(this, &SocketTestClient::OnReadEvent);
-    socket_->SignalWriteEvent.connect(this, &SocketTestClient::OnWriteEvent);
-    socket_->SignalCloseEvent.connect(this, &SocketTestClient::OnCloseEvent);
-  }
-
-  void Flush() {
-    size_t sent = 0;
-    while (sent < send_buffer_.size()) {
-      int result = socket_->Send(&send_buffer_[sent],
-                                 send_buffer_.size() - sent);
-      if (result > 0) {
-        sent += result;
-      } else {
-        break;
-      }
-    }
-    size_t new_size = send_buffer_.size() - sent;
-    memmove(&send_buffer_[0], &send_buffer_[sent], new_size);
-    send_buffer_.resize(new_size);
-  }
-
-  void OnConnectEvent(AsyncSocket* socket) {
-    if (!send_buffer_.empty()) {
-      Flush();
-    }
-  }
-  void OnReadEvent(AsyncSocket* socket) {
-    char data[64 * 1024];
-    int result = socket_->Recv(data, arraysize(data), nullptr);
-    if (result > 0) {
-      recv_buffer_.insert(recv_buffer_.end(), data, data + result);
-    }
-  }
-  void OnWriteEvent(AsyncSocket* socket) {
-    if (!send_buffer_.empty()) {
-      Flush();
-    }
-  }
-  void OnCloseEvent(AsyncSocket* socket, int error) {
-  }
-
-  std::unique_ptr<AsyncSocket> socket_;
-  Buffer send_buffer_, recv_buffer_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// SocketTestServer
-// Creates a simulated server for testing.  Works on real and virtual networks.
-///////////////////////////////////////////////////////////////////////////////
-
-class SocketTestServer : public sigslot::has_slots<> {
- public:
-  SocketTestServer(const SocketAddress& address)
-      : socket_(Thread::Current()->socketserver()
-                ->CreateAsyncSocket(address.family(), SOCK_STREAM))
-  {
-    socket_->SignalReadEvent.connect(this, &SocketTestServer::OnReadEvent);
-    socket_->Bind(address);
-    socket_->Listen(5);
-  }
-  virtual ~SocketTestServer() {
-    clear();
-  }
-
-  size_t size() const { return clients_.size(); }
-  SocketTestClient* client(size_t index) const { return clients_[index]; }
-  SocketTestClient* operator[](size_t index) const { return client(index); }
-
-  void clear() {
-    for (size_t i=0; i<clients_.size(); ++i) {
-      delete clients_[i];
-    }
-    clients_.clear();
-  }
-
- private:
-  void OnReadEvent(AsyncSocket* socket) {
-    AsyncSocket* accepted = static_cast<AsyncSocket*>(socket_->Accept(nullptr));
-    if (!accepted)
-      return;
-    clients_.push_back(new SocketTestClient(accepted));
-  }
-
-  std::unique_ptr<AsyncSocket> socket_;
-  std::vector<SocketTestClient*> clients_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Unittest predicates which are similar to STREQ, but for raw memory
-///////////////////////////////////////////////////////////////////////////////
-
-inline ::testing::AssertionResult CmpHelperMemEq(
-    const char* expected_expression,
-    const char* expected_length_expression,
-    const char* actual_expression,
-    const char* actual_length_expression,
-    const void* expected,
-    size_t expected_length,
-    const void* actual,
-    size_t actual_length) {
-  if ((expected_length == actual_length)
-      && (0 == memcmp(expected, actual, expected_length))) {
-    return ::testing::AssertionSuccess();
-  }
-
-  ::testing::Message msg;
-  msg << "Value of: " << actual_expression
-      << " [" << actual_length_expression << "]";
-  if (true) {  //!actual_value.Equals(actual_expression)) {
-    size_t buffer_size = actual_length * 2 + 1;
-    char* buffer = STACK_ARRAY(char, buffer_size);
-    hex_encode(buffer, buffer_size,
-               reinterpret_cast<const char*>(actual), actual_length);
-    msg << "\n  Actual: " << buffer << " [" << actual_length << "]";
-  }
-
-  msg << "\nExpected: " << expected_expression
-      << " [" << expected_length_expression << "]";
-  if (true) {  //!expected_value.Equals(expected_expression)) {
-    size_t buffer_size = expected_length * 2 + 1;
-    char* buffer = STACK_ARRAY(char, buffer_size);
-    hex_encode(buffer, buffer_size,
-               reinterpret_cast<const char*>(expected), expected_length);
-    msg << "\nWhich is: " << buffer << " [" << expected_length << "]";
-  }
-
-  return AssertionFailure(msg);
-}
-
-#define EXPECT_MEMEQ(expected, expected_length, actual, actual_length) \
-  EXPECT_PRED_FORMAT4(::testing::CmpHelperMemEq, expected, expected_length, \
-                      actual, actual_length)
-
-#define ASSERT_MEMEQ(expected, expected_length, actual, actual_length) \
-  ASSERT_PRED_FORMAT4(::testing::CmpHelperMemEq, expected, expected_length, \
-                      actual, actual_length)
-
-///////////////////////////////////////////////////////////////////////////////
-// Helpers for initializing constant memory with integers in a particular byte
-// order
-///////////////////////////////////////////////////////////////////////////////
-
-#define BYTE_CAST(x) static_cast<uint8_t>((x)&0xFF)
-
-// Declare a N-bit integer as a little-endian sequence of bytes
-#define LE16(x) BYTE_CAST(((uint16_t)x) >> 0), BYTE_CAST(((uint16_t)x) >> 8)
-
-#define LE32(x) \
-  BYTE_CAST(((uint32_t)x) >> 0), BYTE_CAST(((uint32_t)x) >> 8), \
-      BYTE_CAST(((uint32_t)x) >> 16), BYTE_CAST(((uint32_t)x) >> 24)
-
-#define LE64(x) \
-  BYTE_CAST(((uint64_t)x) >> 0), BYTE_CAST(((uint64_t)x) >> 8),       \
-      BYTE_CAST(((uint64_t)x) >> 16), BYTE_CAST(((uint64_t)x) >> 24), \
-      BYTE_CAST(((uint64_t)x) >> 32), BYTE_CAST(((uint64_t)x) >> 40), \
-      BYTE_CAST(((uint64_t)x) >> 48), BYTE_CAST(((uint64_t)x) >> 56)
-
-// Declare a N-bit integer as a big-endian (Internet) sequence of bytes
-#define BE16(x) BYTE_CAST(((uint16_t)x) >> 8), BYTE_CAST(((uint16_t)x) >> 0)
-
-#define BE32(x) \
-  BYTE_CAST(((uint32_t)x) >> 24), BYTE_CAST(((uint32_t)x) >> 16), \
-      BYTE_CAST(((uint32_t)x) >> 8), BYTE_CAST(((uint32_t)x) >> 0)
-
-#define BE64(x) \
-  BYTE_CAST(((uint64_t)x) >> 56), BYTE_CAST(((uint64_t)x) >> 48),     \
-      BYTE_CAST(((uint64_t)x) >> 40), BYTE_CAST(((uint64_t)x) >> 32), \
-      BYTE_CAST(((uint64_t)x) >> 24), BYTE_CAST(((uint64_t)x) >> 16), \
-      BYTE_CAST(((uint64_t)x) >> 8), BYTE_CAST(((uint64_t)x) >> 0)
-
-// Declare a N-bit integer as a this-endian (local machine) sequence of bytes
-#ifndef BIG_ENDIAN
-#define BIG_ENDIAN 1
-#endif  // BIG_ENDIAN
-
-#if BIG_ENDIAN
-#define TE16 BE16
-#define TE32 BE32
-#define TE64 BE64
-#else  // !BIG_ENDIAN
-#define TE16 LE16
-#define TE32 LE32
-#define TE64 LE64
-#endif  // !BIG_ENDIAN
-
-///////////////////////////////////////////////////////////////////////////////
-
-// Helpers for determining if X/screencasting is available (on linux).
-
-#define MAYBE_SKIP_SCREENCAST_TEST() \
-  if (!testing::IsScreencastingAvailable()) { \
-    LOG(LS_WARNING) << "Skipping test, since it doesn't have the requisite " \
-                    << "X environment for screen capture."; \
-    return; \
-  } \
-
-#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
-struct XDisplay {
-  XDisplay() : display_(XOpenDisplay(nullptr)) {}
-  ~XDisplay() { if (display_) XCloseDisplay(display_); }
-  bool IsValid() const { return display_ != nullptr; }
-  operator Display*() { return display_; }
- private:
-  Display* display_;
-};
-#endif
-
-// Returns true if screencasting is available. When false, anything that uses
-// screencasting features may fail.
-inline bool IsScreencastingAvailable() {
-#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
-  XDisplay display;
-  if (!display.IsValid()) {
-    LOG(LS_WARNING) << "No X Display available.";
-    return false;
-  }
-  int ignored_int, major_version, minor_version;
-  if (!XRRQueryExtension(display, &ignored_int, &ignored_int) ||
-      !XRRQueryVersion(display, &major_version, &minor_version) ||
-      major_version < 1 ||
-      (major_version < 2 && minor_version < 3)) {
-    LOG(LS_WARNING) << "XRandr version: " << major_version << "."
-                    << minor_version;
-    LOG(LS_WARNING) << "XRandr is not supported or is too old (pre 1.3).";
-    return false;
-  }
-#endif
-  return true;
-}
-
-}  // namespace testing
-}  // namespace webrtc
-
-#endif  // WEBRTC_BASE_TESTUTILS_H__
+#endif  // WEBRTC_BASE_TESTUTILS_H_