Avoid using gmock private macros

Summary: [Folly] Avoid using gmock private macros - instead, use only the public interface.

Reviewed By: knekritz

Differential Revision: D7752463

fbshipit-source-id: 625465e7ec93613869e259fe1fe0b08aee7bb7d0

folly/io/async/test/MockAsyncSSLSocket.h

@@ -29,13 +29,23 @@ class MockAsyncSSLSocket : public AsyncSSLSocket {
       : AsyncSocket(base),
         AsyncSSLSocket(ctx, base, deferSecurityNegotiation) {}
 
-  GMOCK_METHOD5_(, noexcept, ,
-   connect,
-   void(AsyncSocket::ConnectCallback*,
-    const folly::SocketAddress&,
-    int,
-    const OptionMap&,
-    const folly::SocketAddress&));
+  MOCK_METHOD5(
+      connect_,
+      void(
+          AsyncSocket::ConnectCallback*,
+          const folly::SocketAddress&,
+          int,
+          const OptionMap&,
+          const folly::SocketAddress&));
+  void connect(
+      AsyncSocket::ConnectCallback* callback,
+      const folly::SocketAddress& address,
+      int timeout,
+      const OptionMap& options,
+      const folly::SocketAddress& bindAddr) noexcept override {
+    connect_(callback, address, timeout, options, bindAddr);
+  }
+
   MOCK_CONST_METHOD1(getLocalAddress, void(folly::SocketAddress*));
   MOCK_CONST_METHOD1(getPeerAddress, void(folly::SocketAddress*));
   MOCK_METHOD0(closeNow, void());

folly/io/async/test/MockAsyncSocket.h

@@ -30,12 +30,22 @@ class MockAsyncSocket : public AsyncSocket {
   explicit MockAsyncSocket(EventBase* base) : AsyncSocket(base) {
   }
 
-  GMOCK_METHOD5_(, noexcept, , connect,
-      void(AsyncSocket::ConnectCallback*,
-           const folly::SocketAddress&,
-           int,
-           const OptionMap&,
-           const folly::SocketAddress&));
+  MOCK_METHOD5(
+      connect_,
+      void(
+          AsyncSocket::ConnectCallback*,
+          const folly::SocketAddress&,
+          int,
+          const OptionMap&,
+          const folly::SocketAddress&));
+  void connect(
+      AsyncSocket::ConnectCallback* callback,
+      const folly::SocketAddress& address,
+      int timeout,
+      const OptionMap& options,
+      const folly::SocketAddress& bindAddr) noexcept override {
+    connect_(callback, address, timeout, options, bindAddr);
+  }
 
   MOCK_CONST_METHOD1(getPeerAddress,
                      void(folly::SocketAddress*));

folly/io/async/test/MockAsyncTransport.h

@@ -68,32 +68,54 @@ class MockAsyncTransport: public AsyncTransportWrapper {
 
 class MockReplaySafetyCallback : public AsyncTransport::ReplaySafetyCallback {
  public:
-  GMOCK_METHOD0_(, noexcept, , onReplaySafe, void());
+  MOCK_METHOD0(onReplaySafe_, void());
+  void onReplaySafe() noexcept override {
+    onReplaySafe_();
+  }
 };
 
 class MockReadCallback: public AsyncTransportWrapper::ReadCallback {
  public:
   MOCK_METHOD2(getReadBuffer, void(void**, size_t*));
-  GMOCK_METHOD1_(, noexcept, , readDataAvailable, void(size_t));
-  GMOCK_METHOD0_(, noexcept, , isBufferMovable, bool());
-  GMOCK_METHOD1_(, noexcept, ,
-      readBufferAvailableInternal,
-      void(std::unique_ptr<folly::IOBuf>&));
-  GMOCK_METHOD0_(, noexcept, , readEOF, void());
-  GMOCK_METHOD1_(, noexcept, , readErr,
-                 void(const AsyncSocketException&));
 
+  MOCK_METHOD1(readDataAvailable_, void(size_t));
+  void readDataAvailable(size_t size) noexcept override {
+    readDataAvailable_(size);
+  }
+
+  MOCK_METHOD0(isBufferMovable_, bool());
+  bool isBufferMovable() noexcept override {
+    return isBufferMovable_();
+  }
+
+  MOCK_METHOD1(readBufferAvailable_, void(std::unique_ptr<folly::IOBuf>&));
   void readBufferAvailable(std::unique_ptr<folly::IOBuf> readBuf)
     noexcept override {
-    readBufferAvailableInternal(readBuf);
+    readBufferAvailable_(readBuf);
+  }
+
+  MOCK_METHOD0(readEOF_, void());
+  void readEOF() noexcept override {
+    readEOF_();
+  }
+
+  MOCK_METHOD1(readErr_, void(const AsyncSocketException&));
+  void readErr(const AsyncSocketException& ex) noexcept override {
+    readErr_(ex);
   }
 };
 
 class MockWriteCallback: public AsyncTransportWrapper::WriteCallback {
  public:
-  GMOCK_METHOD0_(, noexcept, , writeSuccess, void());
-  GMOCK_METHOD2_(, noexcept, , writeErr,
-                 void(size_t, const AsyncSocketException&));
+  MOCK_METHOD0(writeSuccess_, void());
+  void writeSuccess() noexcept override {
+    writeSuccess_();
+  }
+
+  MOCK_METHOD2(writeErr_, void(size_t, const AsyncSocketException&));
+  void writeErr(size_t size, const AsyncSocketException& ex) noexcept override {
+    writeErr_(size, ex);
+  }
 };
 
 } // namespace test