diff --git a/build/fbcode_builder/manifests/mvfst b/build/fbcode_builder/manifests/mvfst
index 3fe11b331..4f72a9192 100644
--- a/build/fbcode_builder/manifests/mvfst
+++ b/build/fbcode_builder/manifests/mvfst
@@ -25,7 +25,7 @@ folly
 fizz
 
 [dependencies.all(test=on, not(os=windows))]
-googletest
+googletest_1_8
 
 [shipit.pathmap]
 fbcode/quic/public_root = .
diff --git a/build/fbcode_builder/manifests/proxygen b/build/fbcode_builder/manifests/proxygen
index d9d337f19..5452a2454 100644
--- a/build/fbcode_builder/manifests/proxygen
+++ b/build/fbcode_builder/manifests/proxygen
@@ -32,7 +32,7 @@ wangle
 mvfst
 
 [dependencies.test=on]
-googletest
+googletest_1_8
 
 [shipit.pathmap]
 fbcode/proxygen/public_tld = .
diff --git a/build_helper.sh b/build_helper.sh
index 8413fc12b..0544ff592 100755
--- a/build_helper.sh
+++ b/build_helper.sh
@@ -210,7 +210,7 @@ function setup_googletest() {
   fi
   cd "$GTEST_DIR"
   git fetch --tags
-  git checkout release-1.10.0
+  git checkout release-1.8.0
   echo -e "${COLOR_GREEN}Building googletest ${COLOR_OFF}"
   mkdir -p "$GTEST_BUILD_DIR"
   cd "$GTEST_BUILD_DIR" || exit
diff --git a/cmake/QuicTest.cmake b/cmake/QuicTest.cmake
index 797991782..b5eea82fe 100644
--- a/cmake/QuicTest.cmake
+++ b/cmake/QuicTest.cmake
@@ -6,8 +6,8 @@
 include(CTest)
 
 if(BUILD_TESTS)
-  find_package(GMock 1.10.0 MODULE REQUIRED)
-  find_package(GTest 1.10.0 MODULE REQUIRED)
+  find_package(GMock 1.8.0 MODULE REQUIRED)
+  find_package(GTest 1.8.0 MODULE REQUIRED)
 endif()
 
 function(quic_add_test)
diff --git a/quic/api/test/MockQuicSocket.h b/quic/api/test/MockQuicSocket.h
index a7d3ac996..c00531509 100644
--- a/quic/api/test/MockQuicSocket.h
+++ b/quic/api/test/MockQuicSocket.h
@@ -23,112 +23,93 @@ class MockQuicSocket : public QuicSocket {
       ConnectionCallback* connCb)
       : setupCb_(setupCb), connCb_(connCb) {}
 
-  MOCK_METHOD(bool, good, (), (const));
-  MOCK_METHOD(bool, replaySafe, (), (const));
-  MOCK_METHOD(bool, error, (), (const));
-  MOCK_METHOD(void, close, (folly::Optional<QuicError>));
-  MOCK_METHOD(void, closeGracefully, ());
-  MOCK_METHOD(void, closeNow, (folly::Optional<QuicError>));
-  MOCK_METHOD(
-      folly::Optional<quic::ConnectionId>,
+  MOCK_CONST_METHOD0(good, bool());
+  MOCK_CONST_METHOD0(replaySafe, bool());
+  MOCK_CONST_METHOD0(error, bool());
+  MOCK_METHOD1(close, void(folly::Optional<QuicError>));
+  MOCK_METHOD0(closeGracefully, void());
+  MOCK_METHOD1(closeNow, void(folly::Optional<QuicError>));
+  MOCK_CONST_METHOD0(
       getClientConnectionId,
-      (),
-      (const));
-  MOCK_METHOD(const TransportSettings&, getTransportSettings, (), (const));
-  MOCK_METHOD(
-      folly::Optional<quic::ConnectionId>,
+      folly::Optional<quic::ConnectionId>());
+  MOCK_CONST_METHOD0(getTransportSettings, const TransportSettings&());
+  MOCK_CONST_METHOD0(
       getServerConnectionId,
-      (),
-      (const));
-  MOCK_METHOD(
-      folly::Optional<quic::ConnectionId>,
+      folly::Optional<quic::ConnectionId>());
+  MOCK_CONST_METHOD0(
       getClientChosenDestConnectionId,
-      (),
-      (const));
-  MOCK_METHOD(const folly::SocketAddress&, getPeerAddress, (), (const));
-  MOCK_METHOD(const folly::SocketAddress&, getOriginalPeerAddress, (), (const));
-  MOCK_METHOD(const folly::SocketAddress&, getLocalAddress, (), (const));
-  MOCK_METHOD(folly::EventBase*, getEventBase, (), (const));
-  MOCK_METHOD(
-      (folly::Expected<size_t, LocalErrorCode>),
+      folly::Optional<quic::ConnectionId>());
+  MOCK_CONST_METHOD0(getPeerAddress, const folly::SocketAddress&());
+  MOCK_CONST_METHOD0(getOriginalPeerAddress, const folly::SocketAddress&());
+  MOCK_CONST_METHOD0(getLocalAddress, const folly::SocketAddress&());
+  MOCK_CONST_METHOD0(getEventBase, folly::EventBase*());
+  MOCK_CONST_METHOD1(
       getStreamReadOffset,
-      (StreamId),
-      (const));
-  MOCK_METHOD(
-      (folly::Expected<size_t, LocalErrorCode>),
+      folly::Expected<size_t, LocalErrorCode>(StreamId));
+  MOCK_CONST_METHOD1(
       getStreamWriteOffset,
-      (StreamId),
-      (const));
-  MOCK_METHOD(
-      (folly::Expected<size_t, LocalErrorCode>),
+      folly::Expected<size_t, LocalErrorCode>(StreamId));
+  MOCK_CONST_METHOD1(
       getStreamWriteBufferedBytes,
-      (StreamId),
-      (const));
-  MOCK_METHOD(QuicSocket::TransportInfo, getTransportInfo, (), (const));
-  MOCK_METHOD(
-      (folly::Expected<QuicSocket::StreamTransportInfo, LocalErrorCode>),
+      folly::Expected<size_t, LocalErrorCode>(StreamId));
+  MOCK_CONST_METHOD0(getTransportInfo, QuicSocket::TransportInfo());
+  MOCK_CONST_METHOD1(
       getStreamTransportInfo,
-      (StreamId),
-      (const));
-  MOCK_METHOD(folly::Optional<std::string>, getAppProtocol, (), (const));
-  MOCK_METHOD(void, setReceiveWindow, (StreamId, size_t));
-  MOCK_METHOD(void, setSendBuffer, (StreamId, size_t, size_t));
-  MOCK_METHOD(uint64_t, getConnectionBufferAvailable, (), (const));
-  MOCK_METHOD(
-      (folly::Expected<FlowControlState, LocalErrorCode>),
+      folly::Expected<QuicSocket::StreamTransportInfo, LocalErrorCode>(
+          StreamId));
+  MOCK_CONST_METHOD0(getAppProtocol, folly::Optional<std::string>());
+  MOCK_METHOD2(setReceiveWindow, void(StreamId, size_t));
+  MOCK_METHOD3(setSendBuffer, void(StreamId, size_t, size_t));
+  MOCK_CONST_METHOD0(getConnectionBufferAvailable, uint64_t());
+  MOCK_CONST_METHOD0(
       getConnectionFlowControl,
-      (),
-      (const));
-  MOCK_METHOD(
-      (folly::Expected<FlowControlState, LocalErrorCode>),
+      folly::Expected<FlowControlState, LocalErrorCode>());
+  MOCK_CONST_METHOD1(
       getStreamFlowControl,
-      (StreamId),
-      (const));
-  MOCK_METHOD(void, unsetAllReadCallbacks, ());
-  MOCK_METHOD(void, unsetAllPeekCallbacks, ());
-  MOCK_METHOD(void, unsetAllDeliveryCallbacks, ());
-  MOCK_METHOD(void, cancelDeliveryCallbacksForStream, (StreamId));
-  MOCK_METHOD(
-      void,
+      folly::Expected<FlowControlState, LocalErrorCode>(StreamId));
+  MOCK_METHOD0(unsetAllReadCallbacks, void());
+  MOCK_METHOD0(unsetAllPeekCallbacks, void());
+  MOCK_METHOD0(unsetAllDeliveryCallbacks, void());
+  MOCK_METHOD1(cancelDeliveryCallbacksForStream, void(StreamId));
+  MOCK_METHOD2(
       cancelDeliveryCallbacksForStream,
-      (StreamId, uint64_t offset));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      void(StreamId, uint64_t offset));
+  MOCK_METHOD1(
       setConnectionFlowControlWindow,
-      (uint64_t));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(uint64_t));
+  MOCK_METHOD2(
       setStreamFlowControlWindow,
-      (StreamId, uint64_t));
-  MOCK_METHOD(void, setTransportSettings, (TransportSettings));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId, uint64_t));
+  MOCK_METHOD1(setTransportSettings, void(TransportSettings));
+  MOCK_METHOD1(
       setMaxPacingRate,
-      (uint64_t));
+      folly::Expected<folly::Unit, LocalErrorCode>(uint64_t));
   folly::Expected<folly::Unit, LocalErrorCode>
   setKnob(uint64_t knobSpace, uint64_t knobId, Buf knobBlob) override {
     SharedBuf sharedBlob(knobBlob.release());
     return setKnob(knobSpace, knobId, sharedBlob);
   }
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+  MOCK_METHOD3(
       setKnob,
-      (uint64_t, uint64_t, SharedBuf));
-  MOCK_METHOD(bool, isKnobSupported, (), (const));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          uint64_t,
+          uint64_t,
+          SharedBuf));
+  MOCK_CONST_METHOD0(isKnobSupported, bool());
+  MOCK_METHOD3(
       setStreamPriority,
-      (StreamId, uint8_t, bool));
-  MOCK_METHOD(
-      (folly::Expected<Priority, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId, uint8_t, bool));
+  MOCK_METHOD1(
       getStreamPriority,
-      (StreamId));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<Priority, LocalErrorCode>(StreamId));
+  MOCK_METHOD3(
       setReadCallback,
-      (StreamId, ReadCallback*, folly::Optional<ApplicationErrorCode> err));
-  MOCK_METHOD(void, setConnectionSetupCallback, (ConnectionSetupCallback*));
-  MOCK_METHOD(void, setConnectionCallback, (ConnectionCallback*));
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          StreamId,
+          ReadCallback*,
+          folly::Optional<ApplicationErrorCode> err));
+  MOCK_METHOD1(setConnectionSetupCallback, void(ConnectionSetupCallback*));
+  MOCK_METHOD1(setConnectionCallback, void(ConnectionCallback*));
   void setEarlyDataAppParamsFunctions(
       folly::Function<bool(const folly::Optional<std::string>&, const Buf&)
                           const> validator,
@@ -136,18 +117,17 @@ class MockQuicSocket : public QuicSocket {
     earlyDataAppParamsValidator_ = std::move(validator);
     earlyDataAppParamsGetter_ = std::move(getter);
   }
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+  MOCK_METHOD1(
       pauseRead,
-      (StreamId));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
+  MOCK_METHOD1(
       resumeRead,
-      (StreamId));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
+  MOCK_METHOD2(
       stopSending,
-      (StreamId, ApplicationErrorCode));
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          StreamId,
+          ApplicationErrorCode));
   folly::Expected<std::pair<Buf, bool>, LocalErrorCode> read(
       StreamId id,
       size_t maxRead) override {
@@ -160,17 +140,16 @@ class MockQuicSocket : public QuicSocket {
   }
   using ReadResult =
       folly::Expected<std::pair<folly::IOBuf*, bool>, LocalErrorCode>;
-  MOCK_METHOD(ReadResult, readNaked, (StreamId, size_t));
-  MOCK_METHOD(
-      (folly::Expected<StreamId, LocalErrorCode>),
+  MOCK_METHOD2(readNaked, ReadResult(StreamId, size_t));
+  MOCK_METHOD1(
       createBidirectionalStream,
-      (bool));
-  MOCK_METHOD(
-      (folly::Expected<StreamId, LocalErrorCode>),
+      folly::Expected<StreamId, LocalErrorCode>(bool));
+  MOCK_METHOD1(
       createUnidirectionalStream,
-      (bool));
-  MOCK_METHOD(uint64_t, getNumOpenableBidirectionalStreams, (), (const));
-  MOCK_METHOD(uint64_t, getNumOpenableUnidirectionalStreams, (), (const));
+      folly::Expected<StreamId, LocalErrorCode>(bool));
+  MOCK_CONST_METHOD0(getNumOpenableBidirectionalStreams, uint64_t());
+  MOCK_CONST_METHOD0(getNumOpenableUnidirectionalStreams, uint64_t());
+#if defined(MOCK_METHOD)
   MOCK_METHOD((bool), isClientStream, (StreamId), (noexcept));
   MOCK_METHOD((bool), isServerStream, (StreamId), (noexcept));
   MOCK_METHOD((StreamInitiator), getStreamInitiator, (StreamId), (noexcept));
@@ -181,131 +160,136 @@ class MockQuicSocket : public QuicSocket {
       getStreamDirectionality,
       (StreamId),
       (noexcept));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+#else
+  GMOCK_METHOD1_(, noexcept, , isClientStream, bool(StreamId));
+  GMOCK_METHOD1_(, noexcept, , isServerStream, bool(StreamId));
+  GMOCK_METHOD1_(, noexcept, , getStreamInitiator, StreamInitiator(StreamId));
+  GMOCK_METHOD1_(, noexcept, , isBidirectionalStream, bool(StreamId));
+  GMOCK_METHOD1_(, noexcept, , isUnidirectionalStream, bool(StreamId));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      getStreamDirectionality,
+      StreamDirectionality(StreamId));
+#endif
+  MOCK_METHOD1(
       notifyPendingWriteOnConnection,
-      (WriteCallback*));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(WriteCallback*));
+  MOCK_METHOD2(
       notifyPendingWriteOnStream,
-      (StreamId, WriteCallback*));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId, WriteCallback*));
+  MOCK_METHOD1(
       unregisterStreamWriteCallback,
-      (StreamId));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
+  MOCK_METHOD3(
       registerTxCallback,
-      (const StreamId, const uint64_t, ByteEventCallback*));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          const StreamId,
+          const uint64_t,
+          ByteEventCallback*));
+  MOCK_METHOD4(
       registerByteEventCallback,
-      (const ByteEvent::Type,
-       const StreamId,
-       const uint64_t,
-       ByteEventCallback*));
-  MOCK_METHOD(
-      void,
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          const ByteEvent::Type,
+          const StreamId,
+          const uint64_t,
+          ByteEventCallback*));
+  MOCK_METHOD2(
       cancelByteEventCallbacksForStream,
-      (const StreamId id, const folly::Optional<uint64_t>& offset));
-  MOCK_METHOD(
-      void,
+      void(const StreamId id, const folly::Optional<uint64_t>& offset));
+  MOCK_METHOD3(
       cancelByteEventCallbacksForStream,
-      (const ByteEvent::Type,
-       const StreamId id,
-       const folly::Optional<uint64_t>& offset));
-  MOCK_METHOD(void, cancelAllByteEventCallbacks, ());
-  MOCK_METHOD(void, cancelByteEventCallbacks, (const ByteEvent::Type));
-  MOCK_METHOD(
-      size_t,
+      void(
+          const ByteEvent::Type,
+          const StreamId id,
+          const folly::Optional<uint64_t>& offset));
+  MOCK_METHOD0(cancelAllByteEventCallbacks, void());
+  MOCK_METHOD1(cancelByteEventCallbacks, void(const ByteEvent::Type));
+  MOCK_CONST_METHOD1(
       getNumByteEventCallbacksForStream,
-      (const StreamId id),
-      (const));
-  MOCK_METHOD(
-      size_t,
+      size_t(const StreamId id));
+  MOCK_CONST_METHOD2(
       getNumByteEventCallbacksForStream,
-      (const ByteEvent::Type, const StreamId),
-      (const));
+      size_t(const ByteEvent::Type, const StreamId));
   folly::Expected<folly::Unit, LocalErrorCode>
   writeChain(StreamId id, Buf data, bool eof, ByteEventCallback* cb) override {
     SharedBuf sharedData(data.release());
     return writeChain(id, sharedData, eof, cb);
   }
-  MOCK_METHOD(
-      WriteResult,
+  MOCK_METHOD4(
       writeChain,
-      (StreamId, SharedBuf, bool, ByteEventCallback*));
-  MOCK_METHOD(
-      WriteResult,
+      WriteResult(StreamId, SharedBuf, bool, ByteEventCallback*));
+  MOCK_METHOD4(
       writeBufMeta,
-      (StreamId, const BufferMeta&, bool, ByteEventCallback*));
-  MOCK_METHOD(
-      WriteResult,
+      WriteResult(StreamId, const BufferMeta&, bool, ByteEventCallback*));
+  MOCK_METHOD2(
       setDSRPacketizationRequestSenderRef,
-      (StreamId, const std::unique_ptr<DSRPacketizationRequestSender>&));
+      WriteResult(
+          StreamId,
+          const std::unique_ptr<DSRPacketizationRequestSender>&));
   WriteResult setDSRPacketizationRequestSender(
       StreamId streamId,
       std::unique_ptr<DSRPacketizationRequestSender> sender) override {
     return setDSRPacketizationRequestSenderRef(streamId, sender);
   }
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+  MOCK_METHOD3(
       registerDeliveryCallback,
-      (StreamId, uint64_t, ByteEventCallback*));
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          StreamId,
+          uint64_t,
+          ByteEventCallback*));
 
-  MOCK_METHOD(folly::Optional<LocalErrorCode>, shutdownWrite, (StreamId));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+  MOCK_METHOD1(shutdownWrite, folly::Optional<LocalErrorCode>(StreamId));
+  MOCK_METHOD2(
       resetStream,
-      (StreamId, ApplicationErrorCode));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          StreamId,
+          ApplicationErrorCode));
+  MOCK_METHOD2(
       maybeResetStreamFromReadError,
-      (StreamId, QuicErrorCode));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId, QuicErrorCode));
+  MOCK_METHOD1(
       setPingCallback,
-      (PingCallback*));
-  MOCK_METHOD(void, sendPing, (std::chrono::milliseconds));
-  MOCK_METHOD(const QuicConnectionStateBase*, getState, (), (const));
-  MOCK_METHOD(bool, isDetachable, ());
-  MOCK_METHOD(void, attachEventBase, (folly::EventBase*));
-  MOCK_METHOD(void, detachEventBase, ());
-  MOCK_METHOD(folly::Optional<LocalErrorCode>, setControlStream, (StreamId));
+      folly::Expected<folly::Unit, LocalErrorCode>(PingCallback*));
+  MOCK_METHOD1(sendPing, void(std::chrono::milliseconds));
+  MOCK_CONST_METHOD0(getState, const QuicConnectionStateBase*());
+  MOCK_METHOD0(isDetachable, bool());
+  MOCK_METHOD1(attachEventBase, void(folly::EventBase*));
+  MOCK_METHOD0(detachEventBase, void());
+  MOCK_METHOD1(setControlStream, folly::Optional<LocalErrorCode>(StreamId));
 
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+  MOCK_METHOD2(
       setPeekCallback,
-      (StreamId, PeekCallback*));
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId, PeekCallback*));
 
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+  MOCK_METHOD1(
       pausePeek,
-      (StreamId));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
+  MOCK_METHOD1(
       resumePeek,
-      (StreamId));
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
 
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+  MOCK_METHOD2(
       peek,
-      (StreamId,
-       const folly::Function<void(StreamId, const folly::Range<PeekIterator>&)
-                                 const>&));
+      folly::Expected<folly::Unit, LocalErrorCode>(
+          StreamId,
+          const folly::Function<
+              void(StreamId, const folly::Range<PeekIterator>&) const>&));
 
-  MOCK_METHOD(
-      (folly::Expected<
+  MOCK_METHOD3(
+      consume,
+      folly::Expected<
           folly::Unit,
-          std::pair<LocalErrorCode, folly::Optional<uint64_t>>>),
+          std::pair<LocalErrorCode, folly::Optional<uint64_t>>>(
+          StreamId,
+          uint64_t,
+          size_t));
+  MOCK_METHOD2(
       consume,
-      (StreamId, uint64_t, size_t));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
-      consume,
-      (StreamId, size_t));
+      folly::Expected<folly::Unit, LocalErrorCode>(StreamId, size_t));
 
-  MOCK_METHOD(void, setCongestionControl, (CongestionControlType));
+  MOCK_METHOD1(setCongestionControl, void(CongestionControlType));
 
   ConnectionSetupCallback* setupCb_;
   ConnectionCallback* connCb_;
@@ -314,32 +298,28 @@ class MockQuicSocket : public QuicSocket {
       earlyDataAppParamsValidator_;
   folly::Function<Buf()> earlyDataAppParamsGetter_;
 
-  MOCK_METHOD(void, addObserver, (Observer*));
-  MOCK_METHOD(bool, removeObserver, (Observer*));
-  MOCK_METHOD(const ObserverVec&, getObservers, (), (const));
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD1(addObserver, void(Observer*));
+  MOCK_METHOD1(removeObserver, bool(Observer*));
+  MOCK_CONST_METHOD0(getObservers, const ObserverVec&());
+  MOCK_METHOD2(
       resetNonControlStreams,
-      (ApplicationErrorCode, folly::StringPiece));
-  MOCK_METHOD(QuicConnectionStats, getConnectionsStats, (), (const));
-  MOCK_METHOD(
-      (folly::Expected<folly::Unit, LocalErrorCode>),
+      void(ApplicationErrorCode, folly::StringPiece));
+  MOCK_CONST_METHOD0(getConnectionsStats, QuicConnectionStats());
+  MOCK_METHOD1(
       setDatagramCallback,
-      (DatagramCallback*));
-  MOCK_METHOD(uint16_t, getDatagramSizeLimit, (), (const));
+      folly::Expected<folly::Unit, LocalErrorCode>(DatagramCallback*));
+  MOCK_CONST_METHOD0(getDatagramSizeLimit, uint16_t());
   folly::Expected<folly::Unit, LocalErrorCode> writeDatagram(
       Buf data) override {
     SharedBuf sharedData(data.release());
     return writeDatagram(sharedData);
   }
-  MOCK_METHOD(WriteResult, writeDatagram, (SharedBuf));
-  MOCK_METHOD(
-      (folly::Expected<std::vector<ReadDatagram>, LocalErrorCode>),
+  MOCK_METHOD1(writeDatagram, WriteResult(SharedBuf));
+  MOCK_METHOD1(
       readDatagrams,
-      (size_t));
-  MOCK_METHOD(
-      (folly::Expected<std::vector<Buf>, LocalErrorCode>),
+      folly::Expected<std::vector<ReadDatagram>, LocalErrorCode>(size_t));
+  MOCK_METHOD1(
       readDatagramBufs,
-      (size_t));
+      folly::Expected<std::vector<Buf>, LocalErrorCode>(size_t));
 };
 } // namespace quic
diff --git a/quic/api/test/Mocks.h b/quic/api/test/Mocks.h
index f644be353..c7dcf5529 100644
--- a/quic/api/test/Mocks.h
+++ b/quic/api/test/Mocks.h
@@ -34,59 +34,97 @@ class MockFrameScheduler : public FrameScheduler {
     return _scheduleFramesForPacket(&builderIn, writableBytes);
   }
 
+#if defined(MOCK_METHOD)
   MOCK_METHOD((bool), hasData, (), (const));
-  MOCK_METHOD(
-      SchedulingResult,
+#else
+  GMOCK_METHOD0_(, const, , hasData, bool());
+#endif
+  MOCK_METHOD2(
       _scheduleFramesForPacket,
-      (PacketBuilderInterface*, uint32_t));
+      SchedulingResult(PacketBuilderInterface*, uint32_t));
 };
 
 class MockReadCallback : public QuicSocket::ReadCallback {
  public:
   ~MockReadCallback() override = default;
+#if defined(MOCK_METHOD)
   MOCK_METHOD((void), readAvailable, (StreamId), (noexcept));
   MOCK_METHOD((void), readError, (StreamId, QuicError), (noexcept));
+#else
+  GMOCK_METHOD1_(, noexcept, , readAvailable, void(StreamId));
+  GMOCK_METHOD2_(, noexcept, , readError, void(StreamId, QuicError));
+#endif
 };
 
 class MockPeekCallback : public QuicSocket::PeekCallback {
  public:
   ~MockPeekCallback() override = default;
+#if defined(MOCK_METHOD)
   MOCK_METHOD(
       (void),
       onDataAvailable,
       (StreamId, const folly::Range<PeekIterator>&),
       (noexcept));
   MOCK_METHOD((void), peekError, (StreamId, QuicError), (noexcept));
+#else
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      onDataAvailable,
+      void(StreamId, const folly::Range<PeekIterator>&));
+  GMOCK_METHOD2_(, noexcept, , peekError, void(StreamId, QuicError));
+#endif
 };
 
 class MockDatagramCallback : public QuicSocket::DatagramCallback {
  public:
   ~MockDatagramCallback() override = default;
+#if defined(MOCK_METHOD)
   MOCK_METHOD((void), onDatagramsAvailable, (), (noexcept));
+#else
+  GMOCK_METHOD0_(, noexcept, , onDatagramsAvailable, void());
+#endif
 };
 
 class MockWriteCallback : public QuicSocket::WriteCallback {
  public:
   ~MockWriteCallback() override = default;
+
+#if defined(MOCK_METHOD)
   MOCK_METHOD((void), onStreamWriteReady, (StreamId, uint64_t), (noexcept));
   MOCK_METHOD((void), onConnectionWriteReady, (uint64_t), (noexcept));
   MOCK_METHOD((void), onStreamWriteError, (StreamId, QuicError), (noexcept));
   MOCK_METHOD((void), onConnectionWriteError, (QuicError), (noexcept));
+#else
+  GMOCK_METHOD2_(, noexcept, , onStreamWriteReady, void(StreamId, uint64_t));
+  GMOCK_METHOD1_(, noexcept, , onConnectionWriteReady, void(uint64_t));
+  GMOCK_METHOD2_(, noexcept, , onStreamWriteError, void(StreamId, QuicError));
+  GMOCK_METHOD1_(, noexcept, , onConnectionWriteError, void(QuicError));
+#endif
 };
 
 class MockConnectionSetupCallback : public QuicSocket::ConnectionSetupCallback {
  public:
   ~MockConnectionSetupCallback() override = default;
+#if defined(MOCK_METHOD)
   MOCK_METHOD((void), onConnectionSetupError, (QuicError), (noexcept));
   MOCK_METHOD((void), onReplaySafe, (), (noexcept));
   MOCK_METHOD((void), onTransportReady, (), (noexcept));
   MOCK_METHOD((void), onFirstPeerPacketProcessed, (), (noexcept));
+#else
+  GMOCK_METHOD1_(, noexcept, , onConnectionSetupError, void(QuicError));
+  GMOCK_METHOD0_(, noexcept, , onReplaySafe, void());
+  GMOCK_METHOD0_(, noexcept, , onTransportReady, void());
+  GMOCK_METHOD0_(, noexcept, , onFirstPeerPacketProcessed, void());
+#endif
 };
 
 class MockConnectionCallback : public QuicSocket::ConnectionCallback {
  public:
   ~MockConnectionCallback() override = default;
 
+#if defined(MOCK_METHOD)
   MOCK_METHOD((void), onFlowControlUpdate, (StreamId), (noexcept));
   MOCK_METHOD((void), onNewBidirectionalStream, (StreamId), (noexcept));
   MOCK_METHOD((void), onNewUnidirectionalStream, (StreamId), (noexcept));
@@ -105,6 +143,33 @@ class MockConnectionCallback : public QuicSocket::ConnectionCallback {
       onKnobMock,
       (uint64_t, uint64_t, folly::IOBuf*),
       (noexcept));
+#else
+  GMOCK_METHOD1_(, noexcept, , onFlowControlUpdate, void(StreamId));
+  GMOCK_METHOD1_(, noexcept, , onNewBidirectionalStream, void(StreamId));
+  GMOCK_METHOD1_(, noexcept, , onNewUnidirectionalStream, void(StreamId));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      onStopSending,
+      void(StreamId, ApplicationErrorCode));
+  GMOCK_METHOD0_(, noexcept, , onConnectionEnd, void());
+  GMOCK_METHOD1_(, noexcept, , onConnectionError, void(QuicError));
+  GMOCK_METHOD1_(, noexcept, , onBidirectionalStreamsAvailable, void(uint64_t));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      onUnidirectionalStreamsAvailable,
+      void(uint64_t));
+  GMOCK_METHOD0_(, noexcept, , onAppRateLimited, void());
+  GMOCK_METHOD3_(
+      ,
+      noexcept,
+      ,
+      onKnobMock,
+      void(uint64_t, uint64_t, folly::IOBuf*));
+#endif
 
   void onKnob(uint64_t knobSpace, uint64_t knobId, Buf knobBlob) override {
     onKnobMock(knobSpace, knobId, knobBlob.get());
@@ -114,19 +179,18 @@ class MockConnectionCallback : public QuicSocket::ConnectionCallback {
 class MockDeliveryCallback : public QuicSocket::DeliveryCallback {
  public:
   ~MockDeliveryCallback() override = default;
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD3(
       onDeliveryAck,
-      (StreamId, uint64_t, std::chrono::microseconds));
-  MOCK_METHOD(void, onCanceled, (StreamId, uint64_t));
+      void(StreamId, uint64_t, std::chrono::microseconds));
+  MOCK_METHOD2(onCanceled, void(StreamId, uint64_t));
 };
 
 class MockByteEventCallback : public QuicSocket::ByteEventCallback {
  public:
   ~MockByteEventCallback() override = default;
-  MOCK_METHOD(void, onByteEventRegistered, (QuicSocket::ByteEvent));
-  MOCK_METHOD(void, onByteEvent, (QuicSocket::ByteEvent));
-  MOCK_METHOD(void, onByteEventCanceled, (QuicSocket::ByteEvent));
+  MOCK_METHOD1(onByteEventRegistered, void(QuicSocket::ByteEvent));
+  MOCK_METHOD1(onByteEvent, void(QuicSocket::ByteEvent));
+  MOCK_METHOD1(onByteEventCanceled, void(QuicSocket::ByteEvent));
 
   static auto getTxMatcher(StreamId id, uint64_t offset) {
     return AllOf(
@@ -184,10 +248,11 @@ class MockQuicTransport : public QuicServerTransport {
     customDestructor();
   }
 
-  MOCK_METHOD(void, customDestructor, ());
-  MOCK_METHOD(const folly::SocketAddress&, getPeerAddress, (), (const));
-  MOCK_METHOD(const folly::SocketAddress&, getOriginalPeerAddress, (), (const));
+  MOCK_METHOD0(customDestructor, void());
+  MOCK_CONST_METHOD0(getPeerAddress, const folly::SocketAddress&());
+  MOCK_CONST_METHOD0(getOriginalPeerAddress, const folly::SocketAddress&());
 
+#if defined(MOCK_METHOD)
   MOCK_METHOD((folly::EventBase*), getEventBase, (), (const));
   MOCK_METHOD((void), accept, (), ());
   MOCK_METHOD((void), setTransportSettings, (TransportSettings), ());
@@ -237,23 +302,86 @@ class MockQuicTransport : public QuicServerTransport {
       (QuicTransportStatsCallback*),
       (noexcept));
   MOCK_METHOD((void), setConnectionIdAlgo, (ConnectionIdAlgo*), (noexcept));
+#else
+  GMOCK_METHOD0_(, const, , getEventBase, folly::EventBase*());
+  GMOCK_METHOD0_(, , , accept, void());
+  GMOCK_METHOD1_(
+      ,
+      ,
+      ,
+      setOriginalPeerAddress,
+      void(const folly::SocketAddress&));
+  GMOCK_METHOD1_(, , , setTransportSettings, void(TransportSettings));
+  GMOCK_METHOD1_(, noexcept, , setPacingTimer, void(TimerHighRes::SharedPtr));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      onNetworkData,
+      void(const folly::SocketAddress&, const NetworkData&));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      setRoutingCallback,
+      void(QuicServerTransport::RoutingCallback*));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      setHandshakeFinishedCallback,
+      void(QuicServerTransport::HandshakeFinishedCallback*));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      setSupportedVersions,
+      void(const std::vector<QuicVersion>&));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      setServerConnectionIdParams,
+      void(ServerConnectionIdParams));
+  GMOCK_METHOD1_(, noexcept, , close, void(folly::Optional<QuicError>));
+  GMOCK_METHOD1_(, noexcept, , closeNow, void(folly::Optional<QuicError>));
+  GMOCK_METHOD0_(, const, , hasShutdown, bool());
+  GMOCK_METHOD0_(
+      ,
+      const,
+      ,
+      getClientConnectionId,
+      folly::Optional<ConnectionId>());
+  GMOCK_METHOD0_(
+      ,
+      const,
+      ,
+      getClientChosenDestConnectionId,
+      folly::Optional<ConnectionId>());
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      setTransportStatsCallback,
+      void(QuicTransportStatsCallback*));
+  GMOCK_METHOD1_(, noexcept, , setConnectionIdAlgo, void(ConnectionIdAlgo*));
+#endif
 
   void onNetworkData(
       const folly::SocketAddress& peer,
       NetworkData&& networkData) noexcept override {
     onNetworkData(peer, networkData);
   }
-  MOCK_METHOD(void, setBufAccessor, (BufAccessor*));
+  MOCK_METHOD1(setBufAccessor, void(BufAccessor*));
 };
 
 class MockLoopDetectorCallback : public LoopDetectorCallback {
  public:
   ~MockLoopDetectorCallback() override = default;
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD4(
       onSuspiciousWriteLoops,
-      (uint64_t, WriteDataReason, NoWriteReason, const std::string&));
-  MOCK_METHOD(void, onSuspiciousReadLoops, (uint64_t, NoReadReason));
+      void(uint64_t, WriteDataReason, NoWriteReason, const std::string&));
+  MOCK_METHOD2(onSuspiciousReadLoops, void(uint64_t, NoReadReason));
 };
 
 class MockObserver : public Observer {
@@ -261,6 +389,7 @@ class MockObserver : public Observer {
   MockObserver() : Observer(Observer::Config()) {}
   MockObserver(const Observer::Config& observerConfig)
       : Observer(observerConfig) {}
+#if defined(MOCK_METHOD)
   MOCK_METHOD((void), observerAttach, (QuicSocket*), (noexcept));
   MOCK_METHOD((void), observerDetach, (QuicSocket*), (noexcept));
   MOCK_METHOD((void), destroy, (QuicSocket*), (noexcept));
@@ -332,6 +461,92 @@ class MockObserver : public Observer {
       streamClosed,
       (QuicSocket*, const StreamCloseEvent&),
       (noexcept));
+#else
+  GMOCK_METHOD1_(, noexcept, , observerAttach, void(QuicSocket*));
+  GMOCK_METHOD1_(, noexcept, , observerDetach, void(QuicSocket*));
+  GMOCK_METHOD1_(, noexcept, , destroy, void(QuicSocket*));
+  GMOCK_METHOD2_(, noexcept, , evbAttach, void(QuicSocket*, folly::EventBase*));
+  GMOCK_METHOD2_(, noexcept, , evbDetach, void(QuicSocket*, folly::EventBase*));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      close,
+      void(QuicSocket*, const folly::Optional<QuicError>&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      startWritingFromAppLimited,
+      void(QuicSocket*, const AppLimitedEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      packetsWritten,
+      void(QuicSocket*, const PacketsWrittenEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      appRateLimited,
+      void(QuicSocket*, const AppLimitedEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      acksProcessed,
+      void(QuicSocket*, const AcksProcessedEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      packetLossDetected,
+      void(QuicSocket*, const LossEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      rttSampleGenerated,
+      void(QuicSocket*, const PacketRTT&));
+  GMOCK_METHOD1_(, noexcept, , pmtuProbingStarted, void(QuicSocket*));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      pmtuBlackholeDetected,
+      void(QuicSocket*, const PMTUBlackholeEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      pmtuUpperBoundDetected,
+      void(QuicSocket*, const PMTUUpperBoundEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      spuriousLossDetected,
+      void(QuicSocket*, const SpuriousLossEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      knobFrameReceived,
+      void(QuicSocket*, const KnobFrameEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      streamOpened,
+      void(QuicSocket*, const StreamOpenEvent&));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      streamClosed,
+      void(QuicSocket*, const StreamCloseEvent&));
+#endif
 
   static auto getLossPacketNum(PacketNum packetNum) {
     return testing::Field(
diff --git a/quic/api/test/QuicBatchWriterTest.cpp b/quic/api/test/QuicBatchWriterTest.cpp
index 957df222e..27d713a48 100644
--- a/quic/api/test/QuicBatchWriterTest.cpp
+++ b/quic/api/test/QuicBatchWriterTest.cpp
@@ -627,7 +627,7 @@ TEST_P(QuicBatchWriterTest, InplaceWriterBufResidueCheck) {
   EXPECT_EQ(0, rawBuf->headroom());
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicBatchWriterTest,
     QuicBatchWriterTest,
     ::testing::Values(false, true));
diff --git a/quic/api/test/QuicPacketSchedulerTest.cpp b/quic/api/test/QuicPacketSchedulerTest.cpp
index fe7b97ea9..d2d6105da 100644
--- a/quic/api/test/QuicPacketSchedulerTest.cpp
+++ b/quic/api/test/QuicPacketSchedulerTest.cpp
@@ -2209,7 +2209,7 @@ TEST_F(QuicPacketSchedulerTest, ShortHeaderPaddingMaxPacketLength) {
   EXPECT_EQ(packetLength, conn.udpSendPacketLen);
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicPacketSchedulerTests,
     QuicPacketSchedulerTest,
     Values(PacketBuilderType::Regular, PacketBuilderType::Inplace));
diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp
index 9fda36fd9..546e15b25 100644
--- a/quic/api/test/QuicTransportBaseTest.cpp
+++ b/quic/api/test/QuicTransportBaseTest.cpp
@@ -542,7 +542,7 @@ class QuicTransportImplTest : public Test {
 class QuicTransportImplTestClose : public QuicTransportImplTest,
                                    public testing::WithParamInterface<bool> {};
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicTransportImplTest,
     QuicTransportImplTestClose,
     Values(true, false));
@@ -2858,7 +2858,7 @@ quic::StreamId createStream(
   }
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicTransportImplTest,
     QuicTransportImplTestUniBidi,
     Values(true, false));
diff --git a/quic/client/QuicClientAsyncTransport.h b/quic/client/QuicClientAsyncTransport.h
index 19a0e332f..2ef08a605 100644
--- a/quic/client/QuicClientAsyncTransport.h
+++ b/quic/client/QuicClientAsyncTransport.h
@@ -35,7 +35,6 @@ class QuicClientAsyncTransport : public QuicStreamAsyncTransport,
   void onNewBidirectionalStream(StreamId id) noexcept override;
   void onNewUnidirectionalStream(StreamId id) noexcept override;
   void onStopSending(StreamId id, ApplicationErrorCode error) noexcept override;
-  using QuicSocket::ConnectionCallback::ConnectionCallback::onConnectionEnd;
   void onConnectionEnd() noexcept override;
   void onConnectionSetupError(QuicError code) noexcept override {
     onConnectionError(std::move(code));
diff --git a/quic/client/test/Mocks.h b/quic/client/test/Mocks.h
index 09d50d8b6..d1125efd5 100644
--- a/quic/client/test/Mocks.h
+++ b/quic/client/test/Mocks.h
@@ -21,10 +21,9 @@ namespace test {
 
 class MockClientHandshakeFactory : public ClientHandshakeFactory {
  public:
-  MOCK_METHOD(
-      std::unique_ptr<ClientHandshake>,
+  MOCK_METHOD1(
       _makeClientHandshake,
-      (QuicClientConnectionState*));
+      std::unique_ptr<ClientHandshake>(QuicClientConnectionState*));
 
   std::unique_ptr<ClientHandshake>
       makeClientHandshake(QuicClientConnectionState* conn) && override {
@@ -45,43 +44,40 @@ class MockClientHandshake : public ClientHandshake {
       EncryptionLevel encryptionLevel) override {
     doHandshakeImpl(data.get(), encryptionLevel);
   }
-  MOCK_METHOD(void, doHandshakeImpl, (folly::IOBuf*, EncryptionLevel));
-  MOCK_METHOD(
-      bool,
+  MOCK_METHOD2(doHandshakeImpl, void(folly::IOBuf*, EncryptionLevel));
+  MOCK_METHOD2(
       verifyRetryIntegrityTag,
-      (const ConnectionId&, const RetryPacket&));
-  MOCK_METHOD(void, removePsk, (const folly::Optional<std::string>&));
-  MOCK_METHOD(const CryptoFactory&, getCryptoFactory, (), (const));
-  MOCK_METHOD(bool, isTLSResumed, (), (const));
-  MOCK_METHOD(folly::Optional<bool>, getZeroRttRejected, ());
-  MOCK_METHOD(
-      folly::Optional<ServerTransportParameters>,
+      bool(const ConnectionId&, const RetryPacket&));
+  MOCK_METHOD1(removePsk, void(const folly::Optional<std::string>&));
+  MOCK_CONST_METHOD0(getCryptoFactory, const CryptoFactory&());
+  MOCK_CONST_METHOD0(isTLSResumed, bool());
+  MOCK_METHOD0(getZeroRttRejected, folly::Optional<bool>());
+  MOCK_METHOD0(
       getServerTransportParams,
-      ());
-  MOCK_METHOD(void, destroy, ());
+      folly::Optional<ServerTransportParameters>());
+  MOCK_METHOD0(destroy, void());
 
-  MOCK_METHOD(
-      folly::Optional<CachedServerTransportParameters>,
+  MOCK_METHOD1(
       connectImpl,
-      (folly::Optional<std::string>));
-  MOCK_METHOD(EncryptionLevel, getReadRecordLayerEncryptionLevel, ());
-  MOCK_METHOD(void, processSocketData, (folly::IOBufQueue & queue));
-  MOCK_METHOD(bool, matchEarlyParameters, ());
-  MOCK_METHOD(
-      (std::pair<std::unique_ptr<Aead>, std::unique_ptr<PacketNumberCipher>>),
+      folly::Optional<CachedServerTransportParameters>(
+          folly::Optional<std::string>));
+  MOCK_METHOD0(getReadRecordLayerEncryptionLevel, EncryptionLevel());
+  MOCK_METHOD1(processSocketData, void(folly::IOBufQueue& queue));
+  MOCK_METHOD0(matchEarlyParameters, bool());
+  MOCK_METHOD2(
       buildCiphers,
-      (ClientHandshake::CipherKind kind, folly::ByteRange secret));
-  MOCK_METHOD(
-      const folly::Optional<std::string>&,
+      std::pair<std::unique_ptr<Aead>, std::unique_ptr<PacketNumberCipher>>(
+          ClientHandshake::CipherKind kind,
+          folly::ByteRange secret));
+  MOCK_CONST_METHOD0(
       getApplicationProtocol,
-      (),
-      (const));
+      const folly::Optional<std::string>&());
 };
 
 class MockQuicConnectorCallback : public quic::QuicConnector::Callback {
  public:
-  MOCK_METHOD(void, onConnectError, (QuicError));
-  MOCK_METHOD(void, onConnectSuccess, ());
+  MOCK_METHOD1(onConnectError, void(QuicError));
+  MOCK_METHOD0(onConnectSuccess, void());
 };
 
 class MockQuicClientTransport : public quic::QuicClientTransport {
diff --git a/quic/codec/test/Mocks.h b/quic/codec/test/Mocks.h
index 2c1cf7e95..875243603 100644
--- a/quic/codec/test/Mocks.h
+++ b/quic/codec/test/Mocks.h
@@ -17,17 +17,21 @@ namespace test {
 
 class MockConnectionIdAlgo : public ConnectionIdAlgo {
  public:
-  MOCK_METHOD(bool, canParseNonConst, (const ConnectionId& id), (noexcept));
-  MOCK_METHOD(
-      (folly::Expected<ServerConnectionIdParams, QuicInternalException>),
+  GMOCK_METHOD1_(, noexcept, , canParseNonConst, bool(const ConnectionId& id));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
       parseConnectionId,
-      (const ConnectionId&),
-      (noexcept));
-  MOCK_METHOD(
-      (folly::Expected<ConnectionId, QuicInternalException>),
+      folly::Expected<ServerConnectionIdParams, QuicInternalException>(
+          const ConnectionId&));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
       encodeConnectionId,
-      (const ServerConnectionIdParams&),
-      (noexcept));
+      folly::Expected<ConnectionId, QuicInternalException>(
+          const ServerConnectionIdParams&));
 
   bool canParse(const ConnectionId& id) const noexcept override {
     return const_cast<MockConnectionIdAlgo&>(*this).canParseNonConst(id);
@@ -44,32 +48,29 @@ class MockQuicPacketBuilder : public PacketBuilderInterface {
   void insert(std::unique_ptr<folly::IOBuf> buf, size_t limit) override {
     _insert(buf, limit);
   }
-  MOCK_METHOD(void, appendFrame, (QuicWriteFrame));
-  MOCK_METHOD(void, _insert, (std::unique_ptr<folly::IOBuf>&));
-  MOCK_METHOD(void, _insert, (std::unique_ptr<folly::IOBuf>&, size_t));
-  MOCK_METHOD(void, insert, (const BufQueue&, size_t));
-  MOCK_METHOD(void, push, (const uint8_t*, size_t));
-  MOCK_METHOD(void, write, (const QuicInteger&));
+  MOCK_METHOD1(appendFrame, void(QuicWriteFrame));
+  MOCK_METHOD1(_insert, void(std::unique_ptr<folly::IOBuf>&));
+  MOCK_METHOD2(_insert, void(std::unique_ptr<folly::IOBuf>&, size_t));
+  MOCK_METHOD2(insert, void(const BufQueue&, size_t));
+  MOCK_METHOD2(push, void(const uint8_t*, size_t));
+  MOCK_METHOD1(write, void(const QuicInteger&));
 
-  MOCK_METHOD(uint32_t, remainingSpaceInPkt, (), (const));
-  MOCK_METHOD(const PacketHeader&, getPacketHeader, (), (const));
+  GMOCK_METHOD0_(, const, , remainingSpaceInPkt, uint32_t());
+  GMOCK_METHOD0_(, const, , getPacketHeader, const PacketHeader&());
 
-  MOCK_METHOD(void, writeBEUint8, (uint8_t));
-  MOCK_METHOD(void, writeBEUint16, (uint16_t));
-  MOCK_METHOD(void, writeBEUint64, (uint16_t));
+  MOCK_METHOD1(writeBEUint8, void(uint8_t));
+  MOCK_METHOD1(writeBEUint16, void(uint16_t));
+  MOCK_METHOD1(writeBEUint64, void(uint16_t));
 
-  MOCK_METHOD(void, appendBytes, (PacketNum, uint8_t));
-  MOCK_METHOD(
-      void,
-      appendBytesWithAppender,
-      (BufAppender&, PacketNum, uint8_t));
-  MOCK_METHOD(void, appendBytesWithBufWriter, (BufWriter&, PacketNum, uint8_t));
-  MOCK_METHOD(void, accountForCipherOverhead, (uint8_t), (noexcept));
-  MOCK_METHOD(bool, canBuildPacketNonConst, (), (noexcept));
-  MOCK_METHOD(uint32_t, getHeaderBytes, (), (const));
-  MOCK_METHOD(bool, hasFramesPending, (), (const));
-  MOCK_METHOD(void, releaseOutputBufferMock, ());
-  MOCK_METHOD(void, encodePacketHeader, ());
+  MOCK_METHOD2(appendBytes, void(PacketNum, uint8_t));
+  MOCK_METHOD3(appendBytesWithAppender, void(BufAppender&, PacketNum, uint8_t));
+  MOCK_METHOD3(appendBytesWithBufWriter, void(BufWriter&, PacketNum, uint8_t));
+  GMOCK_METHOD1_(, noexcept, , accountForCipherOverhead, void(uint8_t));
+  GMOCK_METHOD0_(, noexcept, , canBuildPacketNonConst, bool());
+  GMOCK_METHOD0_(, const, , getHeaderBytes, uint32_t());
+  GMOCK_METHOD0_(, const, , hasFramesPending, bool());
+  MOCK_METHOD0(releaseOutputBufferMock, void());
+  MOCK_METHOD0(encodePacketHeader, void());
 
   void releaseOutputBuffer() && override {
     releaseOutputBufferMock();
diff --git a/quic/codec/test/PacketNumberTest.cpp b/quic/codec/test/PacketNumberTest.cpp
index 99b1fdc38..7d1b6526b 100644
--- a/quic/codec/test/PacketNumberTest.cpp
+++ b/quic/codec/test/PacketNumberTest.cpp
@@ -63,7 +63,7 @@ TEST_P(Packet32DecodeTest, Decode) {
   EXPECT_EQ(GetParam().expected, decoded) << std::hex << decoded;
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     Packet8DecodeTests,
     Packet8DecodeTest,
     Values(
@@ -72,7 +72,7 @@ INSTANTIATE_TEST_SUITE_P(
         (Packet8DecodeData){0xaa82ffff, 0x01, 0xaa830001},
         (Packet8DecodeData){0xaa82fffe, 0x01, 0xaa830001}));
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     Packet16DecodeTests,
     Packet16DecodeTest,
     Values(
@@ -90,7 +90,7 @@ INSTANTIATE_TEST_SUITE_P(
         (Packet16DecodeData){0xaa82f30e, 0x9b3, 0xaa8309b3},
         (Packet16DecodeData){0xa82f30ea, 0x9b32, 0xa82f9b32}));
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     Packet32DecodeTests,
     Packet32DecodeTest,
     Values(
diff --git a/quic/codec/test/QuicIntegerTest.cpp b/quic/codec/test/QuicIntegerTest.cpp
index fb42192af..10a16e1a7 100644
--- a/quic/codec/test/QuicIntegerTest.cpp
+++ b/quic/codec/test/QuicIntegerTest.cpp
@@ -125,7 +125,7 @@ TEST_F(QuicIntegerEncodeTest, ForceWrongBytes) {
   EXPECT_DEATH(encodeQuicInteger(15293, appendOp, 1), "");
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicIntegerTests,
     QuicIntegerDecodeTest,
     Values(
@@ -138,7 +138,7 @@ INSTANTIATE_TEST_SUITE_P(
         (IntegerParams){37, "C000000000000025", false, 8},
         (IntegerParams){37, "40", true}));
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicIntegerEncodeTests,
     QuicIntegerEncodeTest,
     Values(
diff --git a/quic/codec/test/QuicPacketBuilderTest.cpp b/quic/codec/test/QuicPacketBuilderTest.cpp
index f7c5fa00c..43df7d9e1 100644
--- a/quic/codec/test/QuicPacketBuilderTest.cpp
+++ b/quic/codec/test/QuicPacketBuilderTest.cpp
@@ -785,7 +785,7 @@ TEST_P(QuicPacketBuilderTest, TestCipherOverhead) {
       kDefaultUDPSendPacketLen - cipherOverhead);
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicPacketBuilderTests,
     QuicPacketBuilderTest,
     Values(TestFlavor::Regular, TestFlavor::Inplace));
diff --git a/quic/common/test/MonitoredObjectTest.cpp b/quic/common/test/MonitoredObjectTest.cpp
index f74526d61..3c945ea4d 100644
--- a/quic/common/test/MonitoredObjectTest.cpp
+++ b/quic/common/test/MonitoredObjectTest.cpp
@@ -17,7 +17,7 @@ using namespace ::testing;
 
 class MockObserver {
  public:
-  MOCK_METHOD(void, accessed, (const string&));
+  MOCK_METHOD1(accessed, void(const string&));
 };
 
 TEST(MonitoredObjectTest, TestObserverCalled) {
diff --git a/quic/common/test/TestUtils.h b/quic/common/test/TestUtils.h
index 5a84747ae..da0c9f790 100644
--- a/quic/common/test/TestUtils.h
+++ b/quic/common/test/TestUtils.h
@@ -329,11 +329,9 @@ class FizzCryptoTestFactory : public FizzCryptoFactory {
   std::unique_ptr<PacketNumberCipher> makePacketNumberCipher(
       fizz::CipherSuite) const override;
 
-  MOCK_METHOD(
-      std::unique_ptr<PacketNumberCipher>,
+  MOCK_CONST_METHOD1(
       _makePacketNumberCipher,
-      (folly::ByteRange),
-      (const));
+      std::unique_ptr<PacketNumberCipher>(folly::ByteRange));
 
   std::unique_ptr<PacketNumberCipher> makePacketNumberCipher(
       folly::ByteRange secret) const override;
@@ -399,7 +397,7 @@ class FakeServerHandshake : public FizzServerHandshake {
 
   void accept(std::shared_ptr<ServerTransportParametersExtension>) override {}
 
-  MOCK_METHOD(void, writeNewSessionTicket, (const AppToken&));
+  MOCK_METHOD1(writeNewSessionTicket, void(const AppToken&));
 
   void doHandshake(std::unique_ptr<folly::IOBuf> data, EncryptionLevel)
       override {
diff --git a/quic/congestion_control/test/Mocks.h b/quic/congestion_control/test/Mocks.h
index 305de1509..5524771ad 100644
--- a/quic/congestion_control/test/Mocks.h
+++ b/quic/congestion_control/test/Mocks.h
@@ -15,30 +15,30 @@ class MockMinRttSampler : public BbrCongestionController::MinRttSampler {
  public:
   ~MockMinRttSampler() override = default;
 
-  MOCK_METHOD(std::chrono::microseconds, minRtt, (), (const));
-  MOCK_METHOD(bool, minRttExpired, (), (const));
-  MOCK_METHOD(
-      bool,
+  MOCK_CONST_METHOD0(minRtt, std::chrono::microseconds());
+  MOCK_CONST_METHOD0(minRttExpired, bool());
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
       newRttSample,
-      (std::chrono::microseconds, TimePoint),
-      (noexcept));
-  MOCK_METHOD(void, timestampMinRtt, (TimePoint), (noexcept));
+      bool(std::chrono::microseconds, TimePoint));
+  GMOCK_METHOD1_(, noexcept, , timestampMinRtt, void(TimePoint));
 };
 
 class MockBandwidthSampler : public BbrCongestionController::BandwidthSampler {
  public:
   ~MockBandwidthSampler() override = default;
 
-  MOCK_METHOD(Bandwidth, getBandwidth, (), (const));
-  MOCK_METHOD(Bandwidth, getLatestSample, (), (const));
-  MOCK_METHOD(bool, isAppLimited, (), (const));
+  MOCK_CONST_METHOD0(getBandwidth, Bandwidth());
+  MOCK_CONST_METHOD0(getLatestSample, Bandwidth());
+  MOCK_CONST_METHOD0(isAppLimited, bool());
 
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD2(
       onPacketAcked,
-      (const CongestionController::AckEvent&, uint64_t));
-  MOCK_METHOD(void, onAppLimited, ());
-  MOCK_METHOD(void, setWindowLength, (const uint64_t), (noexcept));
+      void(const CongestionController::AckEvent&, uint64_t));
+  MOCK_METHOD0(onAppLimited, void());
+  GMOCK_METHOD1_(, noexcept, , setWindowLength, void(const uint64_t));
 };
 
 } // namespace test
diff --git a/quic/d6d/test/Mocks.h b/quic/d6d/test/Mocks.h
index 289c18197..151800388 100644
--- a/quic/d6d/test/Mocks.h
+++ b/quic/d6d/test/Mocks.h
@@ -18,11 +18,10 @@ class MockProbeSizeRaiser : public ProbeSizeRaiser {
  public:
   ~MockProbeSizeRaiser() override {}
 
-  MOCK_METHOD(void, onProbeLost, (uint16_t lastProbeSize));
-  MOCK_METHOD(
-      folly::Optional<uint16_t>,
+  MOCK_METHOD1(onProbeLost, void(uint16_t lastProbeSize));
+  MOCK_METHOD1(
       raiseProbeSize,
-      (uint16_t lastProbeSize));
+      folly::Optional<uint16_t>(uint16_t lastProbeSize));
 };
 
 } // namespace test
diff --git a/quic/dsr/frontend/test/Mocks.h b/quic/dsr/frontend/test/Mocks.h
index 85b519ce1..610ebc5bc 100644
--- a/quic/dsr/frontend/test/Mocks.h
+++ b/quic/dsr/frontend/test/Mocks.h
@@ -14,13 +14,13 @@ namespace quic::test {
 
 class MockDSRPacketBuilder : public DSRPacketBuilderBase {
  public:
-  MOCK_METHOD(size_t, remainingSpaceNonConst, (), (noexcept));
+  GMOCK_METHOD0_(, noexcept, , remainingSpaceNonConst, size_t());
 
   size_t remainingSpace() const noexcept override {
     return const_cast<MockDSRPacketBuilder&>(*this).remainingSpaceNonConst();
   }
 
-  MOCK_METHOD(void, addSendInstruction, (SendInstruction&&, uint32_t));
+  MOCK_METHOD2(addSendInstruction, void(SendInstruction&&, uint32_t));
 };
 
 } // namespace quic::test
diff --git a/quic/dsr/test/Mocks.h b/quic/dsr/test/Mocks.h
index e2b0e0508..aa8158266 100644
--- a/quic/dsr/test/Mocks.h
+++ b/quic/dsr/test/Mocks.h
@@ -18,9 +18,9 @@ namespace quic::test {
 
 class MockDSRPacketizationRequestSender : public DSRPacketizationRequestSender {
  public:
-  MOCK_METHOD(bool, addSendInstruction, (const SendInstruction&));
-  MOCK_METHOD(bool, flush, ());
-  MOCK_METHOD(void, release, ());
+  MOCK_METHOD1(addSendInstruction, bool(const SendInstruction&));
+  MOCK_METHOD0(flush, bool());
+  MOCK_METHOD0(release, void());
 };
 
 } // namespace quic::test
diff --git a/quic/fizz/client/handshake/test/MockQuicPskCache.h b/quic/fizz/client/handshake/test/MockQuicPskCache.h
index d5aa0e384..aa5f9081e 100644
--- a/quic/fizz/client/handshake/test/MockQuicPskCache.h
+++ b/quic/fizz/client/handshake/test/MockQuicPskCache.h
@@ -17,8 +17,8 @@
 namespace quic {
 class MockQuicPskCache : public QuicPskCache {
  public:
-  MOCK_METHOD(folly::Optional<QuicCachedPsk>, getPsk, (const std::string&));
-  MOCK_METHOD(void, putPsk, (const std::string&, QuicCachedPsk));
-  MOCK_METHOD(void, removePsk, (const std::string&));
+  MOCK_METHOD1(getPsk, folly::Optional<QuicCachedPsk>(const std::string&));
+  MOCK_METHOD2(putPsk, void(const std::string&, QuicCachedPsk));
+  MOCK_METHOD1(removePsk, void(const std::string&));
 };
 } // namespace quic
diff --git a/quic/fizz/client/test/QuicClientTransportTest.cpp b/quic/fizz/client/test/QuicClientTransportTest.cpp
index b105ef8d6..54da31d37 100644
--- a/quic/fizz/client/test/QuicClientTransportTest.cpp
+++ b/quic/fizz/client/test/QuicClientTransportTest.cpp
@@ -901,7 +901,7 @@ TEST_P(QuicClientTransportIntegrationTest, D6DEnabledTest) {
   eventbase_.loopForever();
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicClientTransportIntegrationTests,
     QuicClientTransportIntegrationTest,
     ::testing::Values(
@@ -1065,21 +1065,22 @@ TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
       onTransportReadyMock();
     }
 
-    MOCK_METHOD(void, onFlowControlUpdate, (StreamId), (noexcept));
-    MOCK_METHOD(void, onNewBidirectionalStream, (StreamId), (noexcept));
-    MOCK_METHOD(void, onNewUnidirectionalStream, (StreamId), (noexcept));
-    MOCK_METHOD(
-        void,
+    GMOCK_METHOD1_(, noexcept, , onFlowControlUpdate, void(StreamId));
+    GMOCK_METHOD1_(, noexcept, , onNewBidirectionalStream, void(StreamId));
+    GMOCK_METHOD1_(, noexcept, , onNewUnidirectionalStream, void(StreamId));
+    GMOCK_METHOD2_(
+        ,
+        noexcept,
+        ,
         onStopSending,
-        (StreamId, ApplicationErrorCode),
-        (noexcept));
-    MOCK_METHOD(void, onTransportReadyMock, (), (noexcept));
-    MOCK_METHOD(void, onReplaySafe, (), (noexcept));
-    MOCK_METHOD(void, onConnectionEnd, (), (noexcept));
+        void(StreamId, ApplicationErrorCode));
+    GMOCK_METHOD0_(, noexcept, , onTransportReadyMock, void());
+    GMOCK_METHOD0_(, noexcept, , onReplaySafe, void());
+    GMOCK_METHOD0_(, noexcept, , onConnectionEnd, void());
     void onConnectionSetupError(QuicError error) noexcept override {
       onConnectionError(std::move(error));
     }
-    MOCK_METHOD(void, onConnectionError, (QuicError), (noexcept));
+    GMOCK_METHOD1_(, noexcept, , onConnectionError, void(QuicError));
 
    private:
     std::shared_ptr<QuicSocket> socket_;
@@ -1962,7 +1963,7 @@ class QuicClientTransportHappyEyeballsTest
   SocketAddress serverAddrV6{"::1", 443};
 };
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicClientTransportHappyEyeballsTests,
     QuicClientTransportHappyEyeballsTest,
     ::testing::Values(
@@ -2137,7 +2138,7 @@ class QuicClientTransportAfterStartTest
     : public QuicClientTransportAfterStartTestBase,
       public testing::WithParamInterface<uint8_t> {};
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicClientZeroLenConnIds,
     QuicClientTransportAfterStartTest,
     ::Values(0, 8));
@@ -3009,7 +3010,7 @@ class QuicClientTransportAfterStartTestClose
     : public QuicClientTransportAfterStartTestBase,
       public testing::WithParamInterface<bool> {};
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicClientTransportAfterStartTestCloseWithError,
     QuicClientTransportAfterStartTestClose,
     Values(true, false));
@@ -3215,7 +3216,7 @@ class QuicClientTransportAfterStartTestTimeout
     : public QuicClientTransportAfterStartTestBase,
       public testing::WithParamInterface<QuicVersion> {};
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicClientTransportAfterStartTestTimeouts,
     QuicClientTransportAfterStartTestTimeout,
     Values(QuicVersion::MVFST, QuicVersion::QUIC_V1, QuicVersion::QUIC_DRAFT));
@@ -5352,7 +5353,7 @@ class QuicProcessDataTest : public QuicClientTransportAfterStartTestBase,
   }
 };
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicClientZeroLenConnIds,
     QuicProcessDataTest,
     ::Values(0, 8));
diff --git a/quic/fizz/handshake/test/FizzPacketNumberCipherTest.cpp b/quic/fizz/handshake/test/FizzPacketNumberCipherTest.cpp
index f84a9ae85..d309dcb16 100644
--- a/quic/fizz/handshake/test/FizzPacketNumberCipherTest.cpp
+++ b/quic/fizz/handshake/test/FizzPacketNumberCipherTest.cpp
@@ -89,7 +89,7 @@ TEST_P(LongPacketNumberCipherTest, TestEncryptDecrypt) {
       GetParam().decryptedPacketNumberBytes);
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     LongPacketNumberCipherTests,
     LongPacketNumberCipherTest,
     ::testing::Values(
diff --git a/quic/handshake/test/Mocks.h b/quic/handshake/test/Mocks.h
index 7886cc1c1..d8ca77bd4 100644
--- a/quic/handshake/test/Mocks.h
+++ b/quic/handshake/test/Mocks.h
@@ -24,10 +24,10 @@ class MockPacketNumberCipher : public PacketNumberCipher {
  public:
   virtual ~MockPacketNumberCipher() = default;
 
-  MOCK_METHOD(void, setKey, (folly::ByteRange key));
-  MOCK_METHOD(HeaderProtectionMask, mask, (folly::ByteRange), (const));
-  MOCK_METHOD(size_t, keyLength, (), (const));
-  MOCK_METHOD(const Buf&, getKey, (), (const));
+  MOCK_METHOD1(setKey, void(folly::ByteRange key));
+  MOCK_CONST_METHOD1(mask, HeaderProtectionMask(folly::ByteRange));
+  MOCK_CONST_METHOD0(keyLength, size_t());
+  MOCK_CONST_METHOD0(getKey, const Buf&());
 
   void setDefaultKey() {
     packetProtectionKey_ = getProtectionKey();
@@ -41,16 +41,15 @@ class MockPacketNumberCipher : public PacketNumberCipher {
 
 class MockAead : public Aead {
  public:
-  MOCK_METHOD(size_t, getCipherOverhead, (), (const));
+  MOCK_CONST_METHOD0(getCipherOverhead, size_t());
 
-  MOCK_METHOD(folly::Optional<TrafficKey>, getKey, (), (const));
-  MOCK_METHOD(
-      std::unique_ptr<folly::IOBuf>,
+  MOCK_CONST_METHOD0(getKey, folly::Optional<TrafficKey>());
+  MOCK_CONST_METHOD3(
       _inplaceEncrypt,
-      (std::unique_ptr<folly::IOBuf> & plaintext,
-       const folly::IOBuf* associatedData,
-       uint64_t seqNum),
-      (const));
+      std::unique_ptr<folly::IOBuf>(
+          std::unique_ptr<folly::IOBuf>& plaintext,
+          const folly::IOBuf* associatedData,
+          uint64_t seqNum));
   std::unique_ptr<folly::IOBuf> inplaceEncrypt(
       std::unique_ptr<folly::IOBuf>&& plaintext,
       const folly::IOBuf* associatedData,
@@ -58,13 +57,12 @@ class MockAead : public Aead {
     return _inplaceEncrypt(plaintext, associatedData, seqNum);
   }
 
-  MOCK_METHOD(
-      std::unique_ptr<folly::IOBuf>,
+  MOCK_CONST_METHOD3(
       _decrypt,
-      (std::unique_ptr<folly::IOBuf> & ciphertext,
-       const folly::IOBuf* associatedData,
-       uint64_t seqNum),
-      (const));
+      std::unique_ptr<folly::IOBuf>(
+          std::unique_ptr<folly::IOBuf>& ciphertext,
+          const folly::IOBuf* associatedData,
+          uint64_t seqNum));
   std::unique_ptr<folly::IOBuf> decrypt(
       std::unique_ptr<folly::IOBuf>&& ciphertext,
       const folly::IOBuf* associatedData,
@@ -72,13 +70,12 @@ class MockAead : public Aead {
     return _decrypt(ciphertext, associatedData, seqNum);
   }
 
-  MOCK_METHOD(
-      folly::Optional<std::unique_ptr<folly::IOBuf>>,
+  MOCK_CONST_METHOD3(
       _tryDecrypt,
-      (std::unique_ptr<folly::IOBuf> & ciphertext,
-       const folly::IOBuf* associatedData,
-       uint64_t seqNum),
-      (const));
+      folly::Optional<std::unique_ptr<folly::IOBuf>>(
+          std::unique_ptr<folly::IOBuf>& ciphertext,
+          const folly::IOBuf* associatedData,
+          uint64_t seqNum));
   folly::Optional<std::unique_ptr<folly::IOBuf>> tryDecrypt(
       std::unique_ptr<folly::IOBuf>&& ciphertext,
       const folly::IOBuf* associatedData,
diff --git a/quic/logging/test/Mocks.h b/quic/logging/test/Mocks.h
index 8bda3ad83..4b6fe9d5d 100644
--- a/quic/logging/test/Mocks.h
+++ b/quic/logging/test/Mocks.h
@@ -16,57 +16,52 @@ class MockQLogger : public QLogger {
   MockQLogger() = delete;
   MockQLogger(VantagePoint vp) : QLogger(vp, kHTTP3ProtocolType) {}
   ~MockQLogger() override = default;
-  MOCK_METHOD(void, addPacket, (const RegularQuicPacket&, uint64_t));
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD2(addPacket, void(const RegularQuicPacket&, uint64_t));
+  MOCK_METHOD3(
       addPacket,
-      (const VersionNegotiationPacket&, uint64_t, bool));
-  MOCK_METHOD(void, addPacket, (const RetryPacket&, uint64_t, bool));
-  MOCK_METHOD(void, addPacket, (const RegularQuicWritePacket&, uint64_t));
-  MOCK_METHOD(void, addConnectionClose, (std::string, std::string, bool, bool));
-  MOCK_METHOD(void, addTransportSummary, (const TransportSummaryArgs&));
-  MOCK_METHOD(
-      void,
+      void(const VersionNegotiationPacket&, uint64_t, bool));
+  MOCK_METHOD3(addPacket, void(const RetryPacket&, uint64_t, bool));
+  MOCK_METHOD2(addPacket, void(const RegularQuicWritePacket&, uint64_t));
+  MOCK_METHOD4(addConnectionClose, void(std::string, std::string, bool, bool));
+  MOCK_METHOD1(addTransportSummary, void(const TransportSummaryArgs&));
+  MOCK_METHOD5(
       addCongestionMetricUpdate,
-      (uint64_t, uint64_t, std::string, std::string, std::string));
-  MOCK_METHOD(
-      void,
+      void(uint64_t, uint64_t, std::string, std::string, std::string));
+  MOCK_METHOD2(
       addPacingMetricUpdate,
-      (uint64_t, std::chrono::microseconds));
-  MOCK_METHOD(
-      void,
+      void(uint64_t, std::chrono::microseconds));
+  MOCK_METHOD3(
       addPacingObservation,
-      (std::string, std::string, std::string));
-  MOCK_METHOD(void, addAppIdleUpdate, (std::string, bool));
-  MOCK_METHOD(void, addPacketDrop, (size_t, std::string));
-  MOCK_METHOD(void, addDatagramReceived, (uint64_t));
-  MOCK_METHOD(void, addLossAlarm, (PacketNum, uint64_t, uint64_t, std::string));
-  MOCK_METHOD(void, addPacketsLost, (PacketNum, uint64_t, uint64_t));
-  MOCK_METHOD(void, addTransportStateUpdate, (std::string));
-  MOCK_METHOD(void, addPacketBuffered, (ProtectionType, uint64_t));
-  MOCK_METHOD(
-      void,
+      void(std::string, std::string, std::string));
+  MOCK_METHOD2(addAppIdleUpdate, void(std::string, bool));
+  MOCK_METHOD2(addPacketDrop, void(size_t, std::string));
+  MOCK_METHOD1(addDatagramReceived, void(uint64_t));
+  MOCK_METHOD4(addLossAlarm, void(PacketNum, uint64_t, uint64_t, std::string));
+  MOCK_METHOD3(addPacketsLost, void(PacketNum, uint64_t, uint64_t));
+  MOCK_METHOD1(addTransportStateUpdate, void(std::string));
+  MOCK_METHOD2(addPacketBuffered, void(ProtectionType, uint64_t));
+  MOCK_METHOD4(
       addMetricUpdate,
-      (std::chrono::microseconds,
-       std::chrono::microseconds,
-       std::chrono::microseconds,
-       std::chrono::microseconds));
-  MOCK_METHOD(
-      void,
+      void(
+          std::chrono::microseconds,
+          std::chrono::microseconds,
+          std::chrono::microseconds,
+          std::chrono::microseconds));
+  MOCK_METHOD3(
       addStreamStateUpdate,
-      (quic::StreamId,
-       std::string,
-       folly::Optional<std::chrono::milliseconds>));
-  MOCK_METHOD(
-      void,
+      void(
+          quic::StreamId,
+          std::string,
+          folly::Optional<std::chrono::milliseconds>));
+  MOCK_METHOD2(
       addBandwidthEstUpdate,
-      (uint64_t, std::chrono::microseconds));
-  MOCK_METHOD(void, addAppLimitedUpdate, ());
-  MOCK_METHOD(void, addAppUnlimitedUpdate, ());
-  MOCK_METHOD(void, addConnectionMigrationUpdate, (bool));
-  MOCK_METHOD(void, addPathValidationEvent, (bool));
-  MOCK_METHOD(void, setDcid, (folly::Optional<ConnectionId>));
-  MOCK_METHOD(void, setScid, (folly::Optional<ConnectionId>));
-  MOCK_METHOD(void, addPriorityUpdate, (quic::StreamId, uint8_t, bool));
+      void(uint64_t, std::chrono::microseconds));
+  MOCK_METHOD0(addAppLimitedUpdate, void());
+  MOCK_METHOD0(addAppUnlimitedUpdate, void());
+  MOCK_METHOD1(addConnectionMigrationUpdate, void(bool));
+  MOCK_METHOD1(addPathValidationEvent, void(bool));
+  MOCK_METHOD1(setDcid, void(folly::Optional<ConnectionId>));
+  MOCK_METHOD1(setScid, void(folly::Optional<ConnectionId>));
+  MOCK_METHOD3(addPriorityUpdate, void(quic::StreamId, uint8_t, bool));
 };
 } // namespace quic::test
diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp
index de5d7217d..40150868c 100644
--- a/quic/loss/test/QuicLossFunctionsTest.cpp
+++ b/quic/loss/test/QuicLossFunctionsTest.cpp
@@ -63,9 +63,9 @@ namespace test {
 
 class MockLossTimeout {
  public:
-  MOCK_METHOD(void, cancelLossTimeout, ());
-  MOCK_METHOD(void, scheduleLossTimeout, (std::chrono::milliseconds));
-  MOCK_METHOD(bool, isLossTimeoutScheduled, ());
+  MOCK_METHOD0(cancelLossTimeout, void());
+  MOCK_METHOD1(scheduleLossTimeout, void(std::chrono::milliseconds));
+  MOCK_METHOD0(isLossTimeoutScheduled, bool());
 };
 
 enum class PacketType {
@@ -2547,7 +2547,7 @@ TEST_F(QuicLossFunctionsTest, LossVisitorDSRTest) {
   EXPECT_FALSE(conn->streamManager->writableDSRStreams().empty());
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicLossFunctionsTests,
     QuicLossFunctionsTest,
     Values(
diff --git a/quic/server/handshake/test/ServerHandshakeTest.cpp b/quic/server/handshake/test/ServerHandshakeTest.cpp
index bc26812a2..8adcc55e6 100644
--- a/quic/server/handshake/test/ServerHandshakeTest.cpp
+++ b/quic/server/handshake/test/ServerHandshakeTest.cpp
@@ -47,7 +47,7 @@ class MockServerHandshakeCallback : public ServerHandshake::HandshakeCallback {
  public:
   ~MockServerHandshakeCallback() override = default;
 
-  MOCK_METHOD(void, onCryptoEventAvailable, (), (noexcept));
+  GMOCK_METHOD0_(, noexcept, , onCryptoEventAvailable, void());
 };
 
 struct TestingServerConnectionState : public QuicServerConnectionState {
diff --git a/quic/server/test/Mocks.h b/quic/server/test/Mocks.h
index ce676cc9f..d7f378932 100644
--- a/quic/server/test/Mocks.h
+++ b/quic/server/test/Mocks.h
@@ -18,11 +18,20 @@ namespace quic {
 
 class MockServerConnectionIdRejector : public ServerConnectionIdRejector {
  public:
+#if defined(MOCK_METHOD)
   MOCK_METHOD(
       (bool),
       rejectConnectionIdNonConst,
       (const ConnectionId),
       (noexcept));
+#else
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      rejectConnectionIdNonConst,
+      bool(const ConnectionId));
+#endif
 
   bool rejectConnectionId(const ConnectionId& id) const noexcept override {
     return const_cast<MockServerConnectionIdRejector&>(*this)
@@ -45,6 +54,7 @@ class MockQuicServerTransportFactory : public QuicServerTransportFactory {
     return _make(evb, socket, addr, ctx);
   }
 
+#if defined(MOCK_METHOD)
   MOCK_METHOD(
       (QuicServerTransport::Ptr),
       _make,
@@ -53,30 +63,42 @@ class MockQuicServerTransportFactory : public QuicServerTransportFactory {
        const folly::SocketAddress&,
        std::shared_ptr<const fizz::server::FizzServerContext>),
       (noexcept));
+#else
+  GMOCK_METHOD4_(
+      ,
+      noexcept,
+      ,
+      _make,
+      QuicServerTransport::Ptr(
+          folly::EventBase* evb,
+          std::unique_ptr<folly::AsyncUDPSocket>& sock,
+          const folly::SocketAddress&,
+          std::shared_ptr<const fizz::server::FizzServerContext>));
+#endif
 };
 
 class MockWorkerCallback : public QuicServerWorker::WorkerCallback {
  public:
   ~MockWorkerCallback() = default;
-  MOCK_METHOD(void, handleWorkerError, (LocalErrorCode));
+  MOCK_METHOD1(handleWorkerError, void(LocalErrorCode));
 
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD5(
       routeDataToWorkerLong,
-      (const folly::SocketAddress&,
-       std::unique_ptr<RoutingData>&,
-       std::unique_ptr<NetworkData>&,
-       folly::Optional<QuicVersion>,
-       bool isForwardedData));
+      void(
+          const folly::SocketAddress&,
+          std::unique_ptr<RoutingData>&,
+          std::unique_ptr<NetworkData>&,
+          folly::Optional<QuicVersion>,
+          bool isForwardedData));
 
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD5(
       routeDataToWorkerShort,
-      (const folly::SocketAddress&,
-       std::unique_ptr<RoutingData>&,
-       std::unique_ptr<NetworkData>&,
-       folly::Optional<QuicVersion>,
-       bool isForwardedData));
+      void(
+          const folly::SocketAddress&,
+          std::unique_ptr<RoutingData>&,
+          std::unique_ptr<NetworkData>&,
+          folly::Optional<QuicVersion>,
+          bool isForwardedData));
 
   void routeDataToWorker(
       const folly::SocketAddress& client,
@@ -102,13 +124,14 @@ class MockQuicUDPSocketFactory : public QuicUDPSocketFactory {
   std::unique_ptr<folly::AsyncUDPSocket> make(folly::EventBase* evb, int fd) {
     return std::unique_ptr<folly::AsyncUDPSocket>(_make(evb, fd));
   }
-  MOCK_METHOD(folly::AsyncUDPSocket*, _make, (folly::EventBase*, int));
+  MOCK_METHOD2(_make, folly::AsyncUDPSocket*(folly::EventBase*, int));
 };
 
 class MockRoutingCallback : public QuicServerTransport::RoutingCallback {
  public:
   ~MockRoutingCallback() override = default;
 
+#if defined(MOCK_METHOD)
   MOCK_METHOD(
       (void),
       onConnectionIdAvailable,
@@ -126,6 +149,29 @@ class MockRoutingCallback : public QuicServerTransport::RoutingCallback {
        const QuicServerTransport::SourceIdentity&,
        const std::vector<ConnectionIdData>&),
       (noexcept));
+#else
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
+      onConnectionIdAvailable,
+      void(QuicServerTransport::Ptr, ConnectionId));
+  GMOCK_METHOD1_(
+      ,
+      noexcept,
+      ,
+      onConnectionIdBound,
+      void(QuicServerTransport::Ptr));
+  GMOCK_METHOD3_(
+      ,
+      noexcept,
+      ,
+      onConnectionUnbound,
+      void(
+          QuicServerTransport*,
+          const QuicServerTransport::SourceIdentity&,
+          const std::vector<ConnectionIdData>& connIdData));
+#endif
 };
 
 class MockHandshakeFinishedCallback
@@ -133,8 +179,13 @@ class MockHandshakeFinishedCallback
  public:
   ~MockHandshakeFinishedCallback() override = default;
 
+#if defined(MOCK_METHOD)
   MOCK_METHOD((void), onHandshakeFinished, (), (noexcept));
   MOCK_METHOD((void), onHandshakeUnfinished, (), (noexcept));
+#else
+  GMOCK_METHOD0_(, noexcept, , onHandshakeFinished, void());
+  GMOCK_METHOD0_(, noexcept, , onHandshakeUnfinished, void());
+#endif
 };
 
 class MockQuicServerTransport : public QuicServerTransport {
diff --git a/quic/server/test/QuicServerTest.cpp b/quic/server/test/QuicServerTest.cpp
index 662d741f2..cb17d9f74 100644
--- a/quic/server/test/QuicServerTest.cpp
+++ b/quic/server/test/QuicServerTest.cpp
@@ -1413,10 +1413,10 @@ TEST_F(QuicServerWorkerTest, AssignBufAccessor) {
 
 class MockAcceptObserver : public AcceptObserver {
  public:
-  MOCK_METHOD(void, accept, (QuicTransportBase* const), (noexcept));
-  MOCK_METHOD(void, acceptorDestroy, (QuicServerWorker*), (noexcept));
-  MOCK_METHOD(void, observerAttach, (QuicServerWorker*), (noexcept));
-  MOCK_METHOD(void, observerDetach, (QuicServerWorker*), (noexcept));
+  GMOCK_METHOD1_(, noexcept, , accept, void(QuicTransportBase* const));
+  GMOCK_METHOD1_(, noexcept, , acceptorDestroy, void(QuicServerWorker*));
+  GMOCK_METHOD1_(, noexcept, , observerAttach, void(QuicServerWorker*));
+  GMOCK_METHOD1_(, noexcept, , observerDetach, void(QuicServerWorker*));
 };
 
 TEST_F(QuicServerWorkerTest, AcceptObserver) {
diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp
index 18e5e8353..0cbce1adc 100644
--- a/quic/server/test/QuicServerTransportTest.cpp
+++ b/quic/server/test/QuicServerTransportTest.cpp
@@ -1734,7 +1734,7 @@ class QuicServerTransportAllowMigrationTest
   }
 };
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicServerTransportMigrationTests,
     QuicServerTransportAllowMigrationTest,
     Values(
@@ -3683,7 +3683,7 @@ class QuicServerTransportPendingDataTest
   }
 };
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicServerTransportPendingDataTests,
     QuicServerTransportPendingDataTest,
     Values(
@@ -3942,7 +3942,7 @@ class QuicServerTransportHandshakeTest
   std::vector<folly::IPAddress> expectedSourceToken_;
 };
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicServerTransportHandshakeTests,
     QuicServerTransportHandshakeTest,
     Values(
diff --git a/quic/state/test/AckHandlersTest.cpp b/quic/state/test/AckHandlersTest.cpp
index b20bf3259..86c849369 100644
--- a/quic/state/test/AckHandlersTest.cpp
+++ b/quic/state/test/AckHandlersTest.cpp
@@ -5235,7 +5235,7 @@ TEST_F(AckEventForAppDataTest, AckEventRetransMultipleDupack) {
   }
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     AckHandlersTests,
     AckHandlersTest,
     Values(
diff --git a/quic/state/test/MockQuicStats.h b/quic/state/test/MockQuicStats.h
index 51fe0cd89..0a43bba34 100644
--- a/quic/state/test/MockQuicStats.h
+++ b/quic/state/test/MockQuicStats.h
@@ -17,64 +17,64 @@ namespace quic {
 
 class MockQuicStats : public QuicTransportStatsCallback {
  public:
-  MOCK_METHOD(void, onPacketReceived, ());
-  MOCK_METHOD(void, onDuplicatedPacketReceived, ());
-  MOCK_METHOD(void, onOutOfOrderPacketReceived, ());
-  MOCK_METHOD(void, onPacketProcessed, ());
-  MOCK_METHOD(void, onPacketSent, ());
-  MOCK_METHOD(void, onPacketRetransmission, ());
-  MOCK_METHOD(void, onPacketLoss, ());
-  MOCK_METHOD(void, onPacketSpuriousLoss, ());
-  MOCK_METHOD(void, onPersistentCongestion, ());
-  MOCK_METHOD(void, onPacketDropped, (PacketDropReason));
-  MOCK_METHOD(void, onPacketForwarded, ());
-  MOCK_METHOD(void, onForwardedPacketReceived, ());
-  MOCK_METHOD(void, onForwardedPacketProcessed, ());
-  MOCK_METHOD(void, onClientInitialReceived, (QuicVersion));
-  MOCK_METHOD(void, onConnectionRateLimited, ());
-  MOCK_METHOD(void, onNewConnection, ());
-  MOCK_METHOD(void, onConnectionClose, (folly::Optional<QuicErrorCode>));
-  MOCK_METHOD(void, onConnectionCloseZeroBytesWritten, ());
-  MOCK_METHOD(void, onNewQuicStream, ());
-  MOCK_METHOD(void, onQuicStreamClosed, ());
-  MOCK_METHOD(void, onQuicStreamReset, (QuicErrorCode));
-  MOCK_METHOD(void, onConnFlowControlUpdate, ());
-  MOCK_METHOD(void, onConnFlowControlBlocked, ());
-  MOCK_METHOD(void, onStatelessReset, ());
-  MOCK_METHOD(void, onStreamFlowControlUpdate, ());
-  MOCK_METHOD(void, onStreamFlowControlBlocked, ());
-  MOCK_METHOD(void, onCwndBlocked, ());
-  MOCK_METHOD(void, onNewCongestionController, (CongestionControlType));
-  MOCK_METHOD(void, onPTO, ());
-  MOCK_METHOD(void, onRead, (size_t));
-  MOCK_METHOD(void, onWrite, (size_t));
-  MOCK_METHOD(void, onUDPSocketWriteError, (SocketErrorType));
-  MOCK_METHOD(void, onConnectionD6DStarted, ());
-  MOCK_METHOD(void, onConnectionPMTURaised, ());
-  MOCK_METHOD(void, onConnectionPMTUBlackholeDetected, ());
-  MOCK_METHOD(void, onConnectionPMTUUpperBoundDetected, ());
-  MOCK_METHOD(void, onTransportKnobApplied, (TransportKnobParamId));
-  MOCK_METHOD(void, onTransportKnobError, (TransportKnobParamId));
-  MOCK_METHOD(void, onServerUnfinishedHandshake, ());
-  MOCK_METHOD(void, onZeroRttBuffered, ());
-  MOCK_METHOD(void, onZeroRttBufferedPruned, ());
-  MOCK_METHOD(void, onZeroRttAccepted, ());
-  MOCK_METHOD(void, onZeroRttRejected, ());
-  MOCK_METHOD(void, onDatagramRead, (size_t));
-  MOCK_METHOD(void, onDatagramWrite, (size_t));
-  MOCK_METHOD(void, onDatagramDroppedOnWrite, ());
-  MOCK_METHOD(void, onDatagramDroppedOnRead, ());
-  MOCK_METHOD(void, onNewTokenReceived, ());
-  MOCK_METHOD(void, onNewTokenIssued, ());
-  MOCK_METHOD(void, onTokenDecryptFailure, ());
-  MOCK_METHOD(void, onShortHeaderPadding, (size_t));
-  MOCK_METHOD(void, onPacerTimerLagged, ());
+  MOCK_METHOD0(onPacketReceived, void());
+  MOCK_METHOD0(onDuplicatedPacketReceived, void());
+  MOCK_METHOD0(onOutOfOrderPacketReceived, void());
+  MOCK_METHOD0(onPacketProcessed, void());
+  MOCK_METHOD0(onPacketSent, void());
+  MOCK_METHOD0(onPacketRetransmission, void());
+  MOCK_METHOD0(onPacketLoss, void());
+  MOCK_METHOD0(onPacketSpuriousLoss, void());
+  MOCK_METHOD0(onPersistentCongestion, void());
+  MOCK_METHOD1(onPacketDropped, void(PacketDropReason));
+  MOCK_METHOD0(onPacketForwarded, void());
+  MOCK_METHOD0(onForwardedPacketReceived, void());
+  MOCK_METHOD0(onForwardedPacketProcessed, void());
+  MOCK_METHOD1(onClientInitialReceived, void(QuicVersion));
+  MOCK_METHOD0(onConnectionRateLimited, void());
+  MOCK_METHOD0(onNewConnection, void());
+  MOCK_METHOD1(onConnectionClose, void(folly::Optional<QuicErrorCode>));
+  MOCK_METHOD0(onConnectionCloseZeroBytesWritten, void());
+  MOCK_METHOD0(onNewQuicStream, void());
+  MOCK_METHOD0(onQuicStreamClosed, void());
+  MOCK_METHOD1(onQuicStreamReset, void(QuicErrorCode));
+  MOCK_METHOD0(onConnFlowControlUpdate, void());
+  MOCK_METHOD0(onConnFlowControlBlocked, void());
+  MOCK_METHOD0(onStatelessReset, void());
+  MOCK_METHOD0(onStreamFlowControlUpdate, void());
+  MOCK_METHOD0(onStreamFlowControlBlocked, void());
+  MOCK_METHOD0(onCwndBlocked, void());
+  MOCK_METHOD1(onNewCongestionController, void(CongestionControlType));
+  MOCK_METHOD0(onPTO, void());
+  MOCK_METHOD1(onRead, void(size_t));
+  MOCK_METHOD1(onWrite, void(size_t));
+  MOCK_METHOD1(onUDPSocketWriteError, void(SocketErrorType));
+  MOCK_METHOD0(onConnectionD6DStarted, void());
+  MOCK_METHOD0(onConnectionPMTURaised, void());
+  MOCK_METHOD0(onConnectionPMTUBlackholeDetected, void());
+  MOCK_METHOD0(onConnectionPMTUUpperBoundDetected, void());
+  MOCK_METHOD1(onTransportKnobApplied, void(TransportKnobParamId));
+  MOCK_METHOD1(onTransportKnobError, void(TransportKnobParamId));
+  MOCK_METHOD0(onServerUnfinishedHandshake, void());
+  MOCK_METHOD0(onZeroRttBuffered, void());
+  MOCK_METHOD0(onZeroRttBufferedPruned, void());
+  MOCK_METHOD0(onZeroRttAccepted, void());
+  MOCK_METHOD0(onZeroRttRejected, void());
+  MOCK_METHOD1(onDatagramRead, void(size_t));
+  MOCK_METHOD1(onDatagramWrite, void(size_t));
+  MOCK_METHOD0(onDatagramDroppedOnWrite, void());
+  MOCK_METHOD0(onDatagramDroppedOnRead, void());
+  MOCK_METHOD0(onNewTokenReceived, void());
+  MOCK_METHOD0(onNewTokenIssued, void());
+  MOCK_METHOD0(onTokenDecryptFailure, void());
+  MOCK_METHOD1(onShortHeaderPadding, void(size_t));
+  MOCK_METHOD0(onPacerTimerLagged, void());
 };
 
 class MockQuicStatsFactory : public QuicTransportStatsCallbackFactory {
  public:
   ~MockQuicStatsFactory() override = default;
 
-  MOCK_METHOD(std::unique_ptr<QuicTransportStatsCallback>, make, ());
+  MOCK_METHOD0(make, std::unique_ptr<QuicTransportStatsCallback>());
 };
 } // namespace quic
diff --git a/quic/state/test/Mocks.h b/quic/state/test/Mocks.h
index 85a594225..f832ee882 100644
--- a/quic/state/test/Mocks.h
+++ b/quic/state/test/Mocks.h
@@ -16,62 +16,59 @@ namespace test {
 class MockCongestionController : public CongestionController {
  public:
   ~MockCongestionController() override {}
-  MOCK_METHOD(void, onRemoveBytesFromInflight, (uint64_t));
-  MOCK_METHOD(void, onPacketSent, (const OutstandingPacket&));
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD1(onRemoveBytesFromInflight, void(uint64_t));
+  MOCK_METHOD1(onPacketSent, void(const OutstandingPacket&));
+  MOCK_METHOD2(
       onPacketAckOrLoss,
-      (const AckEvent* FOLLY_NULLABLE, const LossEvent* FOLLY_NULLABLE));
-  MOCK_METHOD(uint64_t, getWritableBytes, (), (const));
-  MOCK_METHOD(uint64_t, getCongestionWindow, (), (const));
-  MOCK_METHOD(void, onSpuriousLoss, ());
-  MOCK_METHOD(CongestionControlType, type, (), (const));
-  MOCK_METHOD(void, setAppIdle, (bool, TimePoint));
-  MOCK_METHOD(void, setAppLimited, ());
-  MOCK_METHOD(void, setBandwidthUtilizationFactor, (float), (noexcept));
-  MOCK_METHOD(bool, isInBackgroundMode, (), (const));
-  MOCK_METHOD(bool, isAppLimited, (), (const));
-  MOCK_METHOD(void, getStats, (CongestionControllerStats&), (const));
-  MOCK_METHOD(void, setExperimental, (bool));
+      void(const AckEvent* FOLLY_NULLABLE, const LossEvent* FOLLY_NULLABLE));
+  MOCK_CONST_METHOD0(getWritableBytes, uint64_t());
+  MOCK_CONST_METHOD0(getCongestionWindow, uint64_t());
+  MOCK_METHOD0(onSpuriousLoss, void());
+  MOCK_CONST_METHOD0(type, CongestionControlType());
+  GMOCK_METHOD2_(, , , setAppIdle, void(bool, TimePoint));
+  MOCK_METHOD0(setAppLimited, void());
+  GMOCK_METHOD1_(, noexcept, , setBandwidthUtilizationFactor, void(float));
+  MOCK_CONST_METHOD0(isInBackgroundMode, bool());
+  MOCK_CONST_METHOD0(isAppLimited, bool());
+  MOCK_CONST_METHOD1(getStats, void(CongestionControllerStats&));
+  MOCK_METHOD1(setExperimental, void(bool));
 };
 
 class MockPacer : public Pacer {
  public:
-  MOCK_METHOD(
-      void,
+  MOCK_METHOD3(
       refreshPacingRate,
-      (uint64_t, std::chrono::microseconds, TimePoint currentTime));
-  MOCK_METHOD(void, setPacingRate, (uint64_t));
-  MOCK_METHOD(void, setMaxPacingRate, (uint64_t));
-  MOCK_METHOD(void, reset, ());
-  MOCK_METHOD(void, setRttFactor, (uint8_t, uint8_t));
-  MOCK_METHOD(
-      std::chrono::microseconds,
+      void(uint64_t, std::chrono::microseconds, TimePoint currentTime));
+  MOCK_METHOD1(setPacingRate, void(uint64_t));
+  MOCK_METHOD1(setMaxPacingRate, void(uint64_t));
+  MOCK_METHOD0(reset, void());
+  MOCK_METHOD2(setRttFactor, void(uint8_t, uint8_t));
+  MOCK_CONST_METHOD1(
       getTimeUntilNextWrite,
-      (TimePoint),
-      (const));
-  MOCK_METHOD(uint64_t, updateAndGetWriteBatchSize, (TimePoint));
-  MOCK_METHOD(uint64_t, getCachedWriteBatchSize, (), (const));
-  MOCK_METHOD(void, setAppLimited, (bool));
-  MOCK_METHOD(void, onPacketSent, ());
-  MOCK_METHOD(void, onPacketsLoss, ());
-  MOCK_METHOD(void, setExperimental, (bool));
+      std::chrono::microseconds(TimePoint));
+  MOCK_METHOD1(updateAndGetWriteBatchSize, uint64_t(TimePoint));
+  MOCK_CONST_METHOD0(getCachedWriteBatchSize, uint64_t());
+  MOCK_METHOD1(setAppLimited, void(bool));
+  MOCK_METHOD0(onPacketSent, void());
+  MOCK_METHOD0(onPacketsLoss, void());
+  MOCK_METHOD1(setExperimental, void(bool));
 };
 
 class MockPendingPathRateLimiter : public PendingPathRateLimiter {
  public:
   MockPendingPathRateLimiter() : PendingPathRateLimiter(0) {}
-  MOCK_METHOD(void, onPacketSent, (uint64_t));
-  MOCK_METHOD(
-      uint64_t,
+  MOCK_METHOD1(onPacketSent, void(uint64_t));
+  GMOCK_METHOD2_(
+      ,
+      noexcept,
+      ,
       currentCredit,
-      (TimePoint, std::chrono::microseconds),
-      (noexcept));
+      uint64_t(TimePoint, std::chrono::microseconds));
 };
 
 class MockQuicStreamPrioritiesObserver : public QuicStreamPrioritiesObserver {
  public:
-  MOCK_METHOD(void, onStreamPrioritiesChange, ());
+  MOCK_METHOD0(onStreamPrioritiesChange, void());
 };
 } // namespace test
 } // namespace quic
diff --git a/quic/state/test/QuicStateFunctionsTest.cpp b/quic/state/test/QuicStateFunctionsTest.cpp
index 0bea1c14f..cbf3d619c 100644
--- a/quic/state/test/QuicStateFunctionsTest.cpp
+++ b/quic/state/test/QuicStateFunctionsTest.cpp
@@ -82,7 +82,7 @@ TEST_P(UpdateLargestReceivedPacketNumTest, ReceiveOld) {
       currentLargestReceived);
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     UpdateLargestReceivedPacketNumTests,
     UpdateLargestReceivedPacketNumTest,
     Values(
@@ -506,7 +506,7 @@ TEST_P(
   EXPECT_FALSE(verifyToScheduleAckTimeout(conn));
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     UpdateAckStateTests,
     UpdateAckStateTest,
     Values(
@@ -874,7 +874,7 @@ TEST_P(QuicStateFunctionsTest, CloseTranportStateChange) {
   EXPECT_TRUE(conn.pendingEvents.closeTransport);
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
     QuicStateFunctionsTests,
     QuicStateFunctionsTest,
     Values(