From e27b107c6af9a2d64dcf5386295924be582b0376 Mon Sep 17 00:00:00 2001 From: Richard Barnes Date: Mon, 7 Mar 2022 20:03:35 -0800 Subject: [PATCH] use gmock 1.10 instead of 1.8 Summary: See D34622171 for details Differential Revision: D34688142 fbshipit-source-id: ec0c3fdd92723629e0c484388b9ae24436780cf9 --- quic/api/test/MockQuicSocket.h | 394 ++++++++++++---------- quic/api/test/Mocks.h | 251 +------------- quic/api/test/QuicBatchWriterTest.cpp | 2 +- quic/api/test/QuicPacketSchedulerTest.cpp | 2 +- quic/api/test/QuicTransportBaseTest.cpp | 4 +- 5 files changed, 229 insertions(+), 424 deletions(-) diff --git a/quic/api/test/MockQuicSocket.h b/quic/api/test/MockQuicSocket.h index c00531509..a7d3ac996 100644 --- a/quic/api/test/MockQuicSocket.h +++ b/quic/api/test/MockQuicSocket.h @@ -23,93 +23,112 @@ class MockQuicSocket : public QuicSocket { ConnectionCallback* connCb) : setupCb_(setupCb), connCb_(connCb) {} - MOCK_CONST_METHOD0(good, bool()); - MOCK_CONST_METHOD0(replaySafe, bool()); - MOCK_CONST_METHOD0(error, bool()); - MOCK_METHOD1(close, void(folly::Optional)); - MOCK_METHOD0(closeGracefully, void()); - MOCK_METHOD1(closeNow, void(folly::Optional)); - MOCK_CONST_METHOD0( + MOCK_METHOD(bool, good, (), (const)); + MOCK_METHOD(bool, replaySafe, (), (const)); + MOCK_METHOD(bool, error, (), (const)); + MOCK_METHOD(void, close, (folly::Optional)); + MOCK_METHOD(void, closeGracefully, ()); + MOCK_METHOD(void, closeNow, (folly::Optional)); + MOCK_METHOD( + folly::Optional, getClientConnectionId, - folly::Optional()); - MOCK_CONST_METHOD0(getTransportSettings, const TransportSettings&()); - MOCK_CONST_METHOD0( + (), + (const)); + MOCK_METHOD(const TransportSettings&, getTransportSettings, (), (const)); + MOCK_METHOD( + folly::Optional, getServerConnectionId, - folly::Optional()); - MOCK_CONST_METHOD0( + (), + (const)); + MOCK_METHOD( + folly::Optional, getClientChosenDestConnectionId, - folly::Optional()); - 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( + (), + (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), getStreamReadOffset, - folly::Expected(StreamId)); - MOCK_CONST_METHOD1( + (StreamId), + (const)); + MOCK_METHOD( + (folly::Expected), getStreamWriteOffset, - folly::Expected(StreamId)); - MOCK_CONST_METHOD1( + (StreamId), + (const)); + MOCK_METHOD( + (folly::Expected), getStreamWriteBufferedBytes, - folly::Expected(StreamId)); - MOCK_CONST_METHOD0(getTransportInfo, QuicSocket::TransportInfo()); - MOCK_CONST_METHOD1( + (StreamId), + (const)); + MOCK_METHOD(QuicSocket::TransportInfo, getTransportInfo, (), (const)); + MOCK_METHOD( + (folly::Expected), getStreamTransportInfo, - folly::Expected( - StreamId)); - MOCK_CONST_METHOD0(getAppProtocol, folly::Optional()); - 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( + (StreamId), + (const)); + MOCK_METHOD(folly::Optional, 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), getConnectionFlowControl, - folly::Expected()); - MOCK_CONST_METHOD1( + (), + (const)); + MOCK_METHOD( + (folly::Expected), getStreamFlowControl, - folly::Expected(StreamId)); - MOCK_METHOD0(unsetAllReadCallbacks, void()); - MOCK_METHOD0(unsetAllPeekCallbacks, void()); - MOCK_METHOD0(unsetAllDeliveryCallbacks, void()); - MOCK_METHOD1(cancelDeliveryCallbacksForStream, void(StreamId)); - MOCK_METHOD2( + (StreamId), + (const)); + MOCK_METHOD(void, unsetAllReadCallbacks, ()); + MOCK_METHOD(void, unsetAllPeekCallbacks, ()); + MOCK_METHOD(void, unsetAllDeliveryCallbacks, ()); + MOCK_METHOD(void, cancelDeliveryCallbacksForStream, (StreamId)); + MOCK_METHOD( + void, cancelDeliveryCallbacksForStream, - void(StreamId, uint64_t offset)); - MOCK_METHOD1( + (StreamId, uint64_t offset)); + MOCK_METHOD( + (folly::Expected), setConnectionFlowControlWindow, - folly::Expected(uint64_t)); - MOCK_METHOD2( + (uint64_t)); + MOCK_METHOD( + (folly::Expected), setStreamFlowControlWindow, - folly::Expected(StreamId, uint64_t)); - MOCK_METHOD1(setTransportSettings, void(TransportSettings)); - MOCK_METHOD1( + (StreamId, uint64_t)); + MOCK_METHOD(void, setTransportSettings, (TransportSettings)); + MOCK_METHOD( + (folly::Expected), setMaxPacingRate, - folly::Expected(uint64_t)); + (uint64_t)); folly::Expected setKnob(uint64_t knobSpace, uint64_t knobId, Buf knobBlob) override { SharedBuf sharedBlob(knobBlob.release()); return setKnob(knobSpace, knobId, sharedBlob); } - MOCK_METHOD3( + MOCK_METHOD( + (folly::Expected), setKnob, - folly::Expected( - uint64_t, - uint64_t, - SharedBuf)); - MOCK_CONST_METHOD0(isKnobSupported, bool()); - MOCK_METHOD3( + (uint64_t, uint64_t, SharedBuf)); + MOCK_METHOD(bool, isKnobSupported, (), (const)); + MOCK_METHOD( + (folly::Expected), setStreamPriority, - folly::Expected(StreamId, uint8_t, bool)); - MOCK_METHOD1( + (StreamId, uint8_t, bool)); + MOCK_METHOD( + (folly::Expected), getStreamPriority, - folly::Expected(StreamId)); - MOCK_METHOD3( + (StreamId)); + MOCK_METHOD( + (folly::Expected), setReadCallback, - folly::Expected( - StreamId, - ReadCallback*, - folly::Optional err)); - MOCK_METHOD1(setConnectionSetupCallback, void(ConnectionSetupCallback*)); - MOCK_METHOD1(setConnectionCallback, void(ConnectionCallback*)); + (StreamId, ReadCallback*, folly::Optional err)); + MOCK_METHOD(void, setConnectionSetupCallback, (ConnectionSetupCallback*)); + MOCK_METHOD(void, setConnectionCallback, (ConnectionCallback*)); void setEarlyDataAppParamsFunctions( folly::Function&, const Buf&) const> validator, @@ -117,17 +136,18 @@ class MockQuicSocket : public QuicSocket { earlyDataAppParamsValidator_ = std::move(validator); earlyDataAppParamsGetter_ = std::move(getter); } - MOCK_METHOD1( + MOCK_METHOD( + (folly::Expected), pauseRead, - folly::Expected(StreamId)); - MOCK_METHOD1( + (StreamId)); + MOCK_METHOD( + (folly::Expected), resumeRead, - folly::Expected(StreamId)); - MOCK_METHOD2( + (StreamId)); + MOCK_METHOD( + (folly::Expected), stopSending, - folly::Expected( - StreamId, - ApplicationErrorCode)); + (StreamId, ApplicationErrorCode)); folly::Expected, LocalErrorCode> read( StreamId id, size_t maxRead) override { @@ -140,16 +160,17 @@ class MockQuicSocket : public QuicSocket { } using ReadResult = folly::Expected, LocalErrorCode>; - MOCK_METHOD2(readNaked, ReadResult(StreamId, size_t)); - MOCK_METHOD1( + MOCK_METHOD(ReadResult, readNaked, (StreamId, size_t)); + MOCK_METHOD( + (folly::Expected), createBidirectionalStream, - folly::Expected(bool)); - MOCK_METHOD1( + (bool)); + MOCK_METHOD( + (folly::Expected), createUnidirectionalStream, - folly::Expected(bool)); - MOCK_CONST_METHOD0(getNumOpenableBidirectionalStreams, uint64_t()); - MOCK_CONST_METHOD0(getNumOpenableUnidirectionalStreams, uint64_t()); -#if defined(MOCK_METHOD) + (bool)); + MOCK_METHOD(uint64_t, getNumOpenableBidirectionalStreams, (), (const)); + MOCK_METHOD(uint64_t, getNumOpenableUnidirectionalStreams, (), (const)); MOCK_METHOD((bool), isClientStream, (StreamId), (noexcept)); MOCK_METHOD((bool), isServerStream, (StreamId), (noexcept)); MOCK_METHOD((StreamInitiator), getStreamInitiator, (StreamId), (noexcept)); @@ -160,136 +181,131 @@ class MockQuicSocket : public QuicSocket { getStreamDirectionality, (StreamId), (noexcept)); -#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( + MOCK_METHOD( + (folly::Expected), notifyPendingWriteOnConnection, - folly::Expected(WriteCallback*)); - MOCK_METHOD2( + (WriteCallback*)); + MOCK_METHOD( + (folly::Expected), notifyPendingWriteOnStream, - folly::Expected(StreamId, WriteCallback*)); - MOCK_METHOD1( + (StreamId, WriteCallback*)); + MOCK_METHOD( + (folly::Expected), unregisterStreamWriteCallback, - folly::Expected(StreamId)); - MOCK_METHOD3( + (StreamId)); + MOCK_METHOD( + (folly::Expected), registerTxCallback, - folly::Expected( - const StreamId, - const uint64_t, - ByteEventCallback*)); - MOCK_METHOD4( + (const StreamId, const uint64_t, ByteEventCallback*)); + MOCK_METHOD( + (folly::Expected), registerByteEventCallback, - folly::Expected( - const ByteEvent::Type, - const StreamId, - const uint64_t, - ByteEventCallback*)); - MOCK_METHOD2( + (const ByteEvent::Type, + const StreamId, + const uint64_t, + ByteEventCallback*)); + MOCK_METHOD( + void, cancelByteEventCallbacksForStream, - void(const StreamId id, const folly::Optional& offset)); - MOCK_METHOD3( + (const StreamId id, const folly::Optional& offset)); + MOCK_METHOD( + void, cancelByteEventCallbacksForStream, - void( - const ByteEvent::Type, - const StreamId id, - const folly::Optional& offset)); - MOCK_METHOD0(cancelAllByteEventCallbacks, void()); - MOCK_METHOD1(cancelByteEventCallbacks, void(const ByteEvent::Type)); - MOCK_CONST_METHOD1( + (const ByteEvent::Type, + const StreamId id, + const folly::Optional& offset)); + MOCK_METHOD(void, cancelAllByteEventCallbacks, ()); + MOCK_METHOD(void, cancelByteEventCallbacks, (const ByteEvent::Type)); + MOCK_METHOD( + size_t, getNumByteEventCallbacksForStream, - size_t(const StreamId id)); - MOCK_CONST_METHOD2( + (const StreamId id), + (const)); + MOCK_METHOD( + size_t, getNumByteEventCallbacksForStream, - size_t(const ByteEvent::Type, const StreamId)); + (const ByteEvent::Type, const StreamId), + (const)); folly::Expected writeChain(StreamId id, Buf data, bool eof, ByteEventCallback* cb) override { SharedBuf sharedData(data.release()); return writeChain(id, sharedData, eof, cb); } - MOCK_METHOD4( + MOCK_METHOD( + WriteResult, writeChain, - WriteResult(StreamId, SharedBuf, bool, ByteEventCallback*)); - MOCK_METHOD4( + (StreamId, SharedBuf, bool, ByteEventCallback*)); + MOCK_METHOD( + WriteResult, writeBufMeta, - WriteResult(StreamId, const BufferMeta&, bool, ByteEventCallback*)); - MOCK_METHOD2( + (StreamId, const BufferMeta&, bool, ByteEventCallback*)); + MOCK_METHOD( + WriteResult, setDSRPacketizationRequestSenderRef, - WriteResult( - StreamId, - const std::unique_ptr&)); + (StreamId, const std::unique_ptr&)); WriteResult setDSRPacketizationRequestSender( StreamId streamId, std::unique_ptr sender) override { return setDSRPacketizationRequestSenderRef(streamId, sender); } - MOCK_METHOD3( + MOCK_METHOD( + (folly::Expected), registerDeliveryCallback, - folly::Expected( - StreamId, - uint64_t, - ByteEventCallback*)); + (StreamId, uint64_t, ByteEventCallback*)); - MOCK_METHOD1(shutdownWrite, folly::Optional(StreamId)); - MOCK_METHOD2( + MOCK_METHOD(folly::Optional, shutdownWrite, (StreamId)); + MOCK_METHOD( + (folly::Expected), resetStream, - folly::Expected( - StreamId, - ApplicationErrorCode)); - MOCK_METHOD2( + (StreamId, ApplicationErrorCode)); + MOCK_METHOD( + (folly::Expected), maybeResetStreamFromReadError, - folly::Expected(StreamId, QuicErrorCode)); - MOCK_METHOD1( + (StreamId, QuicErrorCode)); + MOCK_METHOD( + (folly::Expected), setPingCallback, - folly::Expected(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(StreamId)); + (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, setControlStream, (StreamId)); - MOCK_METHOD2( + MOCK_METHOD( + (folly::Expected), setPeekCallback, - folly::Expected(StreamId, PeekCallback*)); + (StreamId, PeekCallback*)); - MOCK_METHOD1( + MOCK_METHOD( + (folly::Expected), pausePeek, - folly::Expected(StreamId)); - MOCK_METHOD1( + (StreamId)); + MOCK_METHOD( + (folly::Expected), resumePeek, - folly::Expected(StreamId)); + (StreamId)); - MOCK_METHOD2( + MOCK_METHOD( + (folly::Expected), peek, - folly::Expected( - StreamId, - const folly::Function< - void(StreamId, const folly::Range&) const>&)); + (StreamId, + const folly::Function&) + const>&)); - MOCK_METHOD3( - consume, - folly::Expected< + MOCK_METHOD( + (folly::Expected< folly::Unit, - std::pair>>( - StreamId, - uint64_t, - size_t)); - MOCK_METHOD2( + std::pair>>), consume, - folly::Expected(StreamId, size_t)); + (StreamId, uint64_t, size_t)); + MOCK_METHOD( + (folly::Expected), + consume, + (StreamId, size_t)); - MOCK_METHOD1(setCongestionControl, void(CongestionControlType)); + MOCK_METHOD(void, setCongestionControl, (CongestionControlType)); ConnectionSetupCallback* setupCb_; ConnectionCallback* connCb_; @@ -298,28 +314,32 @@ class MockQuicSocket : public QuicSocket { earlyDataAppParamsValidator_; folly::Function earlyDataAppParamsGetter_; - MOCK_METHOD1(addObserver, void(Observer*)); - MOCK_METHOD1(removeObserver, bool(Observer*)); - MOCK_CONST_METHOD0(getObservers, const ObserverVec&()); - MOCK_METHOD2( + MOCK_METHOD(void, addObserver, (Observer*)); + MOCK_METHOD(bool, removeObserver, (Observer*)); + MOCK_METHOD(const ObserverVec&, getObservers, (), (const)); + MOCK_METHOD( + void, resetNonControlStreams, - void(ApplicationErrorCode, folly::StringPiece)); - MOCK_CONST_METHOD0(getConnectionsStats, QuicConnectionStats()); - MOCK_METHOD1( + (ApplicationErrorCode, folly::StringPiece)); + MOCK_METHOD(QuicConnectionStats, getConnectionsStats, (), (const)); + MOCK_METHOD( + (folly::Expected), setDatagramCallback, - folly::Expected(DatagramCallback*)); - MOCK_CONST_METHOD0(getDatagramSizeLimit, uint16_t()); + (DatagramCallback*)); + MOCK_METHOD(uint16_t, getDatagramSizeLimit, (), (const)); folly::Expected writeDatagram( Buf data) override { SharedBuf sharedData(data.release()); return writeDatagram(sharedData); } - MOCK_METHOD1(writeDatagram, WriteResult(SharedBuf)); - MOCK_METHOD1( + MOCK_METHOD(WriteResult, writeDatagram, (SharedBuf)); + MOCK_METHOD( + (folly::Expected, LocalErrorCode>), readDatagrams, - folly::Expected, LocalErrorCode>(size_t)); - MOCK_METHOD1( + (size_t)); + MOCK_METHOD( + (folly::Expected, LocalErrorCode>), readDatagramBufs, - folly::Expected, LocalErrorCode>(size_t)); + (size_t)); }; } // namespace quic diff --git a/quic/api/test/Mocks.h b/quic/api/test/Mocks.h index c7dcf5529..f644be353 100644 --- a/quic/api/test/Mocks.h +++ b/quic/api/test/Mocks.h @@ -34,97 +34,59 @@ class MockFrameScheduler : public FrameScheduler { return _scheduleFramesForPacket(&builderIn, writableBytes); } -#if defined(MOCK_METHOD) MOCK_METHOD((bool), hasData, (), (const)); -#else - GMOCK_METHOD0_(, const, , hasData, bool()); -#endif - MOCK_METHOD2( + MOCK_METHOD( + SchedulingResult, _scheduleFramesForPacket, - SchedulingResult(PacketBuilderInterface*, uint32_t)); + (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&), (noexcept)); MOCK_METHOD((void), peekError, (StreamId, QuicError), (noexcept)); -#else - GMOCK_METHOD2_( - , - noexcept, - , - onDataAvailable, - void(StreamId, const folly::Range&)); - 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)); @@ -143,33 +105,6 @@ 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()); @@ -179,18 +114,19 @@ class MockConnectionCallback : public QuicSocket::ConnectionCallback { class MockDeliveryCallback : public QuicSocket::DeliveryCallback { public: ~MockDeliveryCallback() override = default; - MOCK_METHOD3( + MOCK_METHOD( + void, onDeliveryAck, - void(StreamId, uint64_t, std::chrono::microseconds)); - MOCK_METHOD2(onCanceled, void(StreamId, uint64_t)); + (StreamId, uint64_t, std::chrono::microseconds)); + MOCK_METHOD(void, onCanceled, (StreamId, uint64_t)); }; class MockByteEventCallback : public QuicSocket::ByteEventCallback { public: ~MockByteEventCallback() override = default; - MOCK_METHOD1(onByteEventRegistered, void(QuicSocket::ByteEvent)); - MOCK_METHOD1(onByteEvent, void(QuicSocket::ByteEvent)); - MOCK_METHOD1(onByteEventCanceled, void(QuicSocket::ByteEvent)); + MOCK_METHOD(void, onByteEventRegistered, (QuicSocket::ByteEvent)); + MOCK_METHOD(void, onByteEvent, (QuicSocket::ByteEvent)); + MOCK_METHOD(void, onByteEventCanceled, (QuicSocket::ByteEvent)); static auto getTxMatcher(StreamId id, uint64_t offset) { return AllOf( @@ -248,11 +184,10 @@ class MockQuicTransport : public QuicServerTransport { customDestructor(); } - MOCK_METHOD0(customDestructor, void()); - MOCK_CONST_METHOD0(getPeerAddress, const folly::SocketAddress&()); - MOCK_CONST_METHOD0(getOriginalPeerAddress, const folly::SocketAddress&()); + MOCK_METHOD(void, customDestructor, ()); + MOCK_METHOD(const folly::SocketAddress&, getPeerAddress, (), (const)); + MOCK_METHOD(const folly::SocketAddress&, getOriginalPeerAddress, (), (const)); -#if defined(MOCK_METHOD) MOCK_METHOD((folly::EventBase*), getEventBase, (), (const)); MOCK_METHOD((void), accept, (), ()); MOCK_METHOD((void), setTransportSettings, (TransportSettings), ()); @@ -302,86 +237,23 @@ 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&)); - GMOCK_METHOD1_( - , - noexcept, - , - setServerConnectionIdParams, - void(ServerConnectionIdParams)); - GMOCK_METHOD1_(, noexcept, , close, void(folly::Optional)); - GMOCK_METHOD1_(, noexcept, , closeNow, void(folly::Optional)); - GMOCK_METHOD0_(, const, , hasShutdown, bool()); - GMOCK_METHOD0_( - , - const, - , - getClientConnectionId, - folly::Optional()); - GMOCK_METHOD0_( - , - const, - , - getClientChosenDestConnectionId, - folly::Optional()); - 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_METHOD1(setBufAccessor, void(BufAccessor*)); + MOCK_METHOD(void, setBufAccessor, (BufAccessor*)); }; class MockLoopDetectorCallback : public LoopDetectorCallback { public: ~MockLoopDetectorCallback() override = default; - MOCK_METHOD4( + MOCK_METHOD( + void, onSuspiciousWriteLoops, - void(uint64_t, WriteDataReason, NoWriteReason, const std::string&)); - MOCK_METHOD2(onSuspiciousReadLoops, void(uint64_t, NoReadReason)); + (uint64_t, WriteDataReason, NoWriteReason, const std::string&)); + MOCK_METHOD(void, onSuspiciousReadLoops, (uint64_t, NoReadReason)); }; class MockObserver : public Observer { @@ -389,7 +261,6 @@ 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)); @@ -461,92 +332,6 @@ 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&)); - 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 27d713a48..957df222e 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_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicBatchWriterTest, QuicBatchWriterTest, ::testing::Values(false, true)); diff --git a/quic/api/test/QuicPacketSchedulerTest.cpp b/quic/api/test/QuicPacketSchedulerTest.cpp index d2d6105da..fe7b97ea9 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_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicPacketSchedulerTests, QuicPacketSchedulerTest, Values(PacketBuilderType::Regular, PacketBuilderType::Inplace)); diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp index 546e15b25..9fda36fd9 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 {}; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicTransportImplTest, QuicTransportImplTestClose, Values(true, false)); @@ -2858,7 +2858,7 @@ quic::StreamId createStream( } } -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicTransportImplTest, QuicTransportImplTestUniBidi, Values(true, false));