From 715dec85be4935c731be3f37dcfffab39875d955 Mon Sep 17 00:00:00 2001 From: Dimitri Bouche Date: Thu, 3 Mar 2022 03:46:03 -0800 Subject: [PATCH] Migrate from googletest 1.8 to googletest 1.10 (#67) Summary: X-link: https://github.com/facebookincubator/hsthrift/pull/67 Updating `googletest` from `1.8.0` to `1.10.0` Reviewed By: mzlee, igorsugak, luciang, meyering, r-barnes Differential Revision: D34351084 fbshipit-source-id: 939b3985ab63a06b6d511ec8711c2d5863bdfea8 --- build/fbcode_builder/manifests/mvfst | 2 +- build/fbcode_builder/manifests/proxygen | 2 +- build_helper.sh | 2 +- cmake/QuicTest.cmake | 4 +- 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 +- quic/client/QuicClientAsyncTransport.h | 1 + quic/client/test/Mocks.h | 56 +-- quic/codec/test/Mocks.h | 65 ++- quic/codec/test/PacketNumberTest.cpp | 6 +- quic/codec/test/QuicIntegerTest.cpp | 4 +- quic/codec/test/QuicPacketBuilderTest.cpp | 2 +- quic/common/test/MonitoredObjectTest.cpp | 2 +- quic/common/test/TestUtils.h | 8 +- quic/congestion_control/test/Mocks.h | 30 +- quic/d6d/test/Mocks.h | 7 +- quic/dsr/frontend/test/Mocks.h | 4 +- quic/dsr/test/Mocks.h | 6 +- .../client/handshake/test/MockQuicPskCache.h | 6 +- .../client/test/QuicClientTransportTest.cpp | 35 +- .../test/FizzPacketNumberCipherTest.cpp | 2 +- quic/handshake/test/Mocks.h | 45 +- quic/logging/test/Mocks.h | 85 ++-- quic/loss/test/QuicLossFunctionsTest.cpp | 8 +- .../handshake/test/ServerHandshakeTest.cpp | 2 +- quic/server/test/Mocks.h | 83 +--- quic/server/test/QuicServerTest.cpp | 8 +- quic/server/test/QuicServerTransportTest.cpp | 6 +- quic/state/test/AckHandlersTest.cpp | 2 +- quic/state/test/MockQuicStats.h | 106 ++--- quic/state/test/Mocks.h | 75 ++-- quic/state/test/QuicStateFunctionsTest.cpp | 6 +- 35 files changed, 547 insertions(+), 776 deletions(-) diff --git a/build/fbcode_builder/manifests/mvfst b/build/fbcode_builder/manifests/mvfst index 4f72a9192..3fe11b331 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_1_8 +googletest [shipit.pathmap] fbcode/quic/public_root = . diff --git a/build/fbcode_builder/manifests/proxygen b/build/fbcode_builder/manifests/proxygen index 5452a2454..d9d337f19 100644 --- a/build/fbcode_builder/manifests/proxygen +++ b/build/fbcode_builder/manifests/proxygen @@ -32,7 +32,7 @@ wangle mvfst [dependencies.test=on] -googletest_1_8 +googletest [shipit.pathmap] fbcode/proxygen/public_tld = . diff --git a/build_helper.sh b/build_helper.sh index 0544ff592..8413fc12b 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.8.0 + git checkout release-1.10.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 b5eea82fe..797991782 100644 --- a/cmake/QuicTest.cmake +++ b/cmake/QuicTest.cmake @@ -6,8 +6,8 @@ include(CTest) if(BUILD_TESTS) - find_package(GMock 1.8.0 MODULE REQUIRED) - find_package(GTest 1.8.0 MODULE REQUIRED) + find_package(GMock 1.10.0 MODULE REQUIRED) + find_package(GTest 1.10.0 MODULE REQUIRED) endif() function(quic_add_test) 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)); diff --git a/quic/client/QuicClientAsyncTransport.h b/quic/client/QuicClientAsyncTransport.h index 2ef08a605..19a0e332f 100644 --- a/quic/client/QuicClientAsyncTransport.h +++ b/quic/client/QuicClientAsyncTransport.h @@ -35,6 +35,7 @@ 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 d1125efd5..09d50d8b6 100644 --- a/quic/client/test/Mocks.h +++ b/quic/client/test/Mocks.h @@ -21,9 +21,10 @@ namespace test { class MockClientHandshakeFactory : public ClientHandshakeFactory { public: - MOCK_METHOD1( + MOCK_METHOD( + std::unique_ptr, _makeClientHandshake, - std::unique_ptr(QuicClientConnectionState*)); + (QuicClientConnectionState*)); std::unique_ptr makeClientHandshake(QuicClientConnectionState* conn) && override { @@ -44,40 +45,43 @@ class MockClientHandshake : public ClientHandshake { EncryptionLevel encryptionLevel) override { doHandshakeImpl(data.get(), encryptionLevel); } - MOCK_METHOD2(doHandshakeImpl, void(folly::IOBuf*, EncryptionLevel)); - MOCK_METHOD2( + MOCK_METHOD(void, doHandshakeImpl, (folly::IOBuf*, EncryptionLevel)); + MOCK_METHOD( + bool, verifyRetryIntegrityTag, - bool(const ConnectionId&, const RetryPacket&)); - MOCK_METHOD1(removePsk, void(const folly::Optional&)); - MOCK_CONST_METHOD0(getCryptoFactory, const CryptoFactory&()); - MOCK_CONST_METHOD0(isTLSResumed, bool()); - MOCK_METHOD0(getZeroRttRejected, folly::Optional()); - MOCK_METHOD0( + (const ConnectionId&, const RetryPacket&)); + MOCK_METHOD(void, removePsk, (const folly::Optional&)); + MOCK_METHOD(const CryptoFactory&, getCryptoFactory, (), (const)); + MOCK_METHOD(bool, isTLSResumed, (), (const)); + MOCK_METHOD(folly::Optional, getZeroRttRejected, ()); + MOCK_METHOD( + folly::Optional, getServerTransportParams, - folly::Optional()); - MOCK_METHOD0(destroy, void()); + ()); + MOCK_METHOD(void, destroy, ()); - MOCK_METHOD1( + MOCK_METHOD( + folly::Optional, connectImpl, - folly::Optional( - folly::Optional)); - MOCK_METHOD0(getReadRecordLayerEncryptionLevel, EncryptionLevel()); - MOCK_METHOD1(processSocketData, void(folly::IOBufQueue& queue)); - MOCK_METHOD0(matchEarlyParameters, bool()); - MOCK_METHOD2( + (folly::Optional)); + MOCK_METHOD(EncryptionLevel, getReadRecordLayerEncryptionLevel, ()); + MOCK_METHOD(void, processSocketData, (folly::IOBufQueue & queue)); + MOCK_METHOD(bool, matchEarlyParameters, ()); + MOCK_METHOD( + (std::pair, std::unique_ptr>), buildCiphers, - std::pair, std::unique_ptr>( - ClientHandshake::CipherKind kind, - folly::ByteRange secret)); - MOCK_CONST_METHOD0( + (ClientHandshake::CipherKind kind, folly::ByteRange secret)); + MOCK_METHOD( + const folly::Optional&, getApplicationProtocol, - const folly::Optional&()); + (), + (const)); }; class MockQuicConnectorCallback : public quic::QuicConnector::Callback { public: - MOCK_METHOD1(onConnectError, void(QuicError)); - MOCK_METHOD0(onConnectSuccess, void()); + MOCK_METHOD(void, onConnectError, (QuicError)); + MOCK_METHOD(void, onConnectSuccess, ()); }; class MockQuicClientTransport : public quic::QuicClientTransport { diff --git a/quic/codec/test/Mocks.h b/quic/codec/test/Mocks.h index 875243603..2c1cf7e95 100644 --- a/quic/codec/test/Mocks.h +++ b/quic/codec/test/Mocks.h @@ -17,21 +17,17 @@ namespace test { class MockConnectionIdAlgo : public ConnectionIdAlgo { public: - GMOCK_METHOD1_(, noexcept, , canParseNonConst, bool(const ConnectionId& id)); - GMOCK_METHOD1_( - , - noexcept, - , + MOCK_METHOD(bool, canParseNonConst, (const ConnectionId& id), (noexcept)); + MOCK_METHOD( + (folly::Expected), parseConnectionId, - folly::Expected( - const ConnectionId&)); - GMOCK_METHOD1_( - , - noexcept, - , + (const ConnectionId&), + (noexcept)); + MOCK_METHOD( + (folly::Expected), encodeConnectionId, - folly::Expected( - const ServerConnectionIdParams&)); + (const ServerConnectionIdParams&), + (noexcept)); bool canParse(const ConnectionId& id) const noexcept override { return const_cast(*this).canParseNonConst(id); @@ -48,29 +44,32 @@ class MockQuicPacketBuilder : public PacketBuilderInterface { void insert(std::unique_ptr buf, size_t limit) override { _insert(buf, limit); } - MOCK_METHOD1(appendFrame, void(QuicWriteFrame)); - MOCK_METHOD1(_insert, void(std::unique_ptr&)); - MOCK_METHOD2(_insert, void(std::unique_ptr&, 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(void, appendFrame, (QuicWriteFrame)); + MOCK_METHOD(void, _insert, (std::unique_ptr&)); + MOCK_METHOD(void, _insert, (std::unique_ptr&, 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&)); - GMOCK_METHOD0_(, const, , remainingSpaceInPkt, uint32_t()); - GMOCK_METHOD0_(, const, , getPacketHeader, const PacketHeader&()); + MOCK_METHOD(uint32_t, remainingSpaceInPkt, (), (const)); + MOCK_METHOD(const PacketHeader&, getPacketHeader, (), (const)); - MOCK_METHOD1(writeBEUint8, void(uint8_t)); - MOCK_METHOD1(writeBEUint16, void(uint16_t)); - MOCK_METHOD1(writeBEUint64, void(uint16_t)); + MOCK_METHOD(void, writeBEUint8, (uint8_t)); + MOCK_METHOD(void, writeBEUint16, (uint16_t)); + MOCK_METHOD(void, writeBEUint64, (uint16_t)); - 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()); + 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, ()); void releaseOutputBuffer() && override { releaseOutputBufferMock(); diff --git a/quic/codec/test/PacketNumberTest.cpp b/quic/codec/test/PacketNumberTest.cpp index 7d1b6526b..99b1fdc38 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_CASE_P( +INSTANTIATE_TEST_SUITE_P( Packet8DecodeTests, Packet8DecodeTest, Values( @@ -72,7 +72,7 @@ INSTANTIATE_TEST_CASE_P( (Packet8DecodeData){0xaa82ffff, 0x01, 0xaa830001}, (Packet8DecodeData){0xaa82fffe, 0x01, 0xaa830001})); -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( Packet16DecodeTests, Packet16DecodeTest, Values( @@ -90,7 +90,7 @@ INSTANTIATE_TEST_CASE_P( (Packet16DecodeData){0xaa82f30e, 0x9b3, 0xaa8309b3}, (Packet16DecodeData){0xa82f30ea, 0x9b32, 0xa82f9b32})); -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( Packet32DecodeTests, Packet32DecodeTest, Values( diff --git a/quic/codec/test/QuicIntegerTest.cpp b/quic/codec/test/QuicIntegerTest.cpp index 10a16e1a7..fb42192af 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_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicIntegerTests, QuicIntegerDecodeTest, Values( @@ -138,7 +138,7 @@ INSTANTIATE_TEST_CASE_P( (IntegerParams){37, "C000000000000025", false, 8}, (IntegerParams){37, "40", true})); -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicIntegerEncodeTests, QuicIntegerEncodeTest, Values( diff --git a/quic/codec/test/QuicPacketBuilderTest.cpp b/quic/codec/test/QuicPacketBuilderTest.cpp index 43df7d9e1..f7c5fa00c 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_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicPacketBuilderTests, QuicPacketBuilderTest, Values(TestFlavor::Regular, TestFlavor::Inplace)); diff --git a/quic/common/test/MonitoredObjectTest.cpp b/quic/common/test/MonitoredObjectTest.cpp index 3c945ea4d..f74526d61 100644 --- a/quic/common/test/MonitoredObjectTest.cpp +++ b/quic/common/test/MonitoredObjectTest.cpp @@ -17,7 +17,7 @@ using namespace ::testing; class MockObserver { public: - MOCK_METHOD1(accessed, void(const string&)); + MOCK_METHOD(void, accessed, (const string&)); }; TEST(MonitoredObjectTest, TestObserverCalled) { diff --git a/quic/common/test/TestUtils.h b/quic/common/test/TestUtils.h index da0c9f790..5a84747ae 100644 --- a/quic/common/test/TestUtils.h +++ b/quic/common/test/TestUtils.h @@ -329,9 +329,11 @@ class FizzCryptoTestFactory : public FizzCryptoFactory { std::unique_ptr makePacketNumberCipher( fizz::CipherSuite) const override; - MOCK_CONST_METHOD1( + MOCK_METHOD( + std::unique_ptr, _makePacketNumberCipher, - std::unique_ptr(folly::ByteRange)); + (folly::ByteRange), + (const)); std::unique_ptr makePacketNumberCipher( folly::ByteRange secret) const override; @@ -397,7 +399,7 @@ class FakeServerHandshake : public FizzServerHandshake { void accept(std::shared_ptr) override {} - MOCK_METHOD1(writeNewSessionTicket, void(const AppToken&)); + MOCK_METHOD(void, writeNewSessionTicket, (const AppToken&)); void doHandshake(std::unique_ptr data, EncryptionLevel) override { diff --git a/quic/congestion_control/test/Mocks.h b/quic/congestion_control/test/Mocks.h index 5524771ad..305de1509 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_CONST_METHOD0(minRtt, std::chrono::microseconds()); - MOCK_CONST_METHOD0(minRttExpired, bool()); - GMOCK_METHOD2_( - , - noexcept, - , + MOCK_METHOD(std::chrono::microseconds, minRtt, (), (const)); + MOCK_METHOD(bool, minRttExpired, (), (const)); + MOCK_METHOD( + bool, newRttSample, - bool(std::chrono::microseconds, TimePoint)); - GMOCK_METHOD1_(, noexcept, , timestampMinRtt, void(TimePoint)); + (std::chrono::microseconds, TimePoint), + (noexcept)); + MOCK_METHOD(void, timestampMinRtt, (TimePoint), (noexcept)); }; class MockBandwidthSampler : public BbrCongestionController::BandwidthSampler { public: ~MockBandwidthSampler() override = default; - MOCK_CONST_METHOD0(getBandwidth, Bandwidth()); - MOCK_CONST_METHOD0(getLatestSample, Bandwidth()); - MOCK_CONST_METHOD0(isAppLimited, bool()); + MOCK_METHOD(Bandwidth, getBandwidth, (), (const)); + MOCK_METHOD(Bandwidth, getLatestSample, (), (const)); + MOCK_METHOD(bool, isAppLimited, (), (const)); - MOCK_METHOD2( + MOCK_METHOD( + void, onPacketAcked, - void(const CongestionController::AckEvent&, uint64_t)); - MOCK_METHOD0(onAppLimited, void()); - GMOCK_METHOD1_(, noexcept, , setWindowLength, void(const uint64_t)); + (const CongestionController::AckEvent&, uint64_t)); + MOCK_METHOD(void, onAppLimited, ()); + MOCK_METHOD(void, setWindowLength, (const uint64_t), (noexcept)); }; } // namespace test diff --git a/quic/d6d/test/Mocks.h b/quic/d6d/test/Mocks.h index 151800388..289c18197 100644 --- a/quic/d6d/test/Mocks.h +++ b/quic/d6d/test/Mocks.h @@ -18,10 +18,11 @@ class MockProbeSizeRaiser : public ProbeSizeRaiser { public: ~MockProbeSizeRaiser() override {} - MOCK_METHOD1(onProbeLost, void(uint16_t lastProbeSize)); - MOCK_METHOD1( + MOCK_METHOD(void, onProbeLost, (uint16_t lastProbeSize)); + MOCK_METHOD( + folly::Optional, raiseProbeSize, - folly::Optional(uint16_t lastProbeSize)); + (uint16_t lastProbeSize)); }; } // namespace test diff --git a/quic/dsr/frontend/test/Mocks.h b/quic/dsr/frontend/test/Mocks.h index 610ebc5bc..85b519ce1 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: - GMOCK_METHOD0_(, noexcept, , remainingSpaceNonConst, size_t()); + MOCK_METHOD(size_t, remainingSpaceNonConst, (), (noexcept)); size_t remainingSpace() const noexcept override { return const_cast(*this).remainingSpaceNonConst(); } - MOCK_METHOD2(addSendInstruction, void(SendInstruction&&, uint32_t)); + MOCK_METHOD(void, addSendInstruction, (SendInstruction&&, uint32_t)); }; } // namespace quic::test diff --git a/quic/dsr/test/Mocks.h b/quic/dsr/test/Mocks.h index aa8158266..e2b0e0508 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_METHOD1(addSendInstruction, bool(const SendInstruction&)); - MOCK_METHOD0(flush, bool()); - MOCK_METHOD0(release, void()); + MOCK_METHOD(bool, addSendInstruction, (const SendInstruction&)); + MOCK_METHOD(bool, flush, ()); + MOCK_METHOD(void, release, ()); }; } // namespace quic::test diff --git a/quic/fizz/client/handshake/test/MockQuicPskCache.h b/quic/fizz/client/handshake/test/MockQuicPskCache.h index aa5f9081e..d5aa0e384 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_METHOD1(getPsk, folly::Optional(const std::string&)); - MOCK_METHOD2(putPsk, void(const std::string&, QuicCachedPsk)); - MOCK_METHOD1(removePsk, void(const std::string&)); + MOCK_METHOD(folly::Optional, getPsk, (const std::string&)); + MOCK_METHOD(void, putPsk, (const std::string&, QuicCachedPsk)); + MOCK_METHOD(void, removePsk, (const std::string&)); }; } // namespace quic diff --git a/quic/fizz/client/test/QuicClientTransportTest.cpp b/quic/fizz/client/test/QuicClientTransportTest.cpp index 54da31d37..b105ef8d6 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_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicClientTransportIntegrationTests, QuicClientTransportIntegrationTest, ::testing::Values( @@ -1065,22 +1065,21 @@ TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) { onTransportReadyMock(); } - GMOCK_METHOD1_(, noexcept, , onFlowControlUpdate, void(StreamId)); - GMOCK_METHOD1_(, noexcept, , onNewBidirectionalStream, void(StreamId)); - GMOCK_METHOD1_(, noexcept, , onNewUnidirectionalStream, void(StreamId)); - GMOCK_METHOD2_( - , - noexcept, - , + MOCK_METHOD(void, onFlowControlUpdate, (StreamId), (noexcept)); + MOCK_METHOD(void, onNewBidirectionalStream, (StreamId), (noexcept)); + MOCK_METHOD(void, onNewUnidirectionalStream, (StreamId), (noexcept)); + MOCK_METHOD( + void, onStopSending, - void(StreamId, ApplicationErrorCode)); - GMOCK_METHOD0_(, noexcept, , onTransportReadyMock, void()); - GMOCK_METHOD0_(, noexcept, , onReplaySafe, void()); - GMOCK_METHOD0_(, noexcept, , onConnectionEnd, void()); + (StreamId, ApplicationErrorCode), + (noexcept)); + MOCK_METHOD(void, onTransportReadyMock, (), (noexcept)); + MOCK_METHOD(void, onReplaySafe, (), (noexcept)); + MOCK_METHOD(void, onConnectionEnd, (), (noexcept)); void onConnectionSetupError(QuicError error) noexcept override { onConnectionError(std::move(error)); } - GMOCK_METHOD1_(, noexcept, , onConnectionError, void(QuicError)); + MOCK_METHOD(void, onConnectionError, (QuicError), (noexcept)); private: std::shared_ptr socket_; @@ -1963,7 +1962,7 @@ class QuicClientTransportHappyEyeballsTest SocketAddress serverAddrV6{"::1", 443}; }; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicClientTransportHappyEyeballsTests, QuicClientTransportHappyEyeballsTest, ::testing::Values( @@ -2138,7 +2137,7 @@ class QuicClientTransportAfterStartTest : public QuicClientTransportAfterStartTestBase, public testing::WithParamInterface {}; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicClientZeroLenConnIds, QuicClientTransportAfterStartTest, ::Values(0, 8)); @@ -3010,7 +3009,7 @@ class QuicClientTransportAfterStartTestClose : public QuicClientTransportAfterStartTestBase, public testing::WithParamInterface {}; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicClientTransportAfterStartTestCloseWithError, QuicClientTransportAfterStartTestClose, Values(true, false)); @@ -3216,7 +3215,7 @@ class QuicClientTransportAfterStartTestTimeout : public QuicClientTransportAfterStartTestBase, public testing::WithParamInterface {}; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicClientTransportAfterStartTestTimeouts, QuicClientTransportAfterStartTestTimeout, Values(QuicVersion::MVFST, QuicVersion::QUIC_V1, QuicVersion::QUIC_DRAFT)); @@ -5353,7 +5352,7 @@ class QuicProcessDataTest : public QuicClientTransportAfterStartTestBase, } }; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicClientZeroLenConnIds, QuicProcessDataTest, ::Values(0, 8)); diff --git a/quic/fizz/handshake/test/FizzPacketNumberCipherTest.cpp b/quic/fizz/handshake/test/FizzPacketNumberCipherTest.cpp index d309dcb16..f84a9ae85 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_CASE_P( +INSTANTIATE_TEST_SUITE_P( LongPacketNumberCipherTests, LongPacketNumberCipherTest, ::testing::Values( diff --git a/quic/handshake/test/Mocks.h b/quic/handshake/test/Mocks.h index d8ca77bd4..7886cc1c1 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_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&()); + 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)); void setDefaultKey() { packetProtectionKey_ = getProtectionKey(); @@ -41,15 +41,16 @@ class MockPacketNumberCipher : public PacketNumberCipher { class MockAead : public Aead { public: - MOCK_CONST_METHOD0(getCipherOverhead, size_t()); + MOCK_METHOD(size_t, getCipherOverhead, (), (const)); - MOCK_CONST_METHOD0(getKey, folly::Optional()); - MOCK_CONST_METHOD3( + MOCK_METHOD(folly::Optional, getKey, (), (const)); + MOCK_METHOD( + std::unique_ptr, _inplaceEncrypt, - std::unique_ptr( - std::unique_ptr& plaintext, - const folly::IOBuf* associatedData, - uint64_t seqNum)); + (std::unique_ptr & plaintext, + const folly::IOBuf* associatedData, + uint64_t seqNum), + (const)); std::unique_ptr inplaceEncrypt( std::unique_ptr&& plaintext, const folly::IOBuf* associatedData, @@ -57,12 +58,13 @@ class MockAead : public Aead { return _inplaceEncrypt(plaintext, associatedData, seqNum); } - MOCK_CONST_METHOD3( + MOCK_METHOD( + std::unique_ptr, _decrypt, - std::unique_ptr( - std::unique_ptr& ciphertext, - const folly::IOBuf* associatedData, - uint64_t seqNum)); + (std::unique_ptr & ciphertext, + const folly::IOBuf* associatedData, + uint64_t seqNum), + (const)); std::unique_ptr decrypt( std::unique_ptr&& ciphertext, const folly::IOBuf* associatedData, @@ -70,12 +72,13 @@ class MockAead : public Aead { return _decrypt(ciphertext, associatedData, seqNum); } - MOCK_CONST_METHOD3( + MOCK_METHOD( + folly::Optional>, _tryDecrypt, - folly::Optional>( - std::unique_ptr& ciphertext, - const folly::IOBuf* associatedData, - uint64_t seqNum)); + (std::unique_ptr & ciphertext, + const folly::IOBuf* associatedData, + uint64_t seqNum), + (const)); folly::Optional> tryDecrypt( std::unique_ptr&& ciphertext, const folly::IOBuf* associatedData, diff --git a/quic/logging/test/Mocks.h b/quic/logging/test/Mocks.h index 4b6fe9d5d..8bda3ad83 100644 --- a/quic/logging/test/Mocks.h +++ b/quic/logging/test/Mocks.h @@ -16,52 +16,57 @@ class MockQLogger : public QLogger { MockQLogger() = delete; MockQLogger(VantagePoint vp) : QLogger(vp, kHTTP3ProtocolType) {} ~MockQLogger() override = default; - MOCK_METHOD2(addPacket, void(const RegularQuicPacket&, uint64_t)); - MOCK_METHOD3( + MOCK_METHOD(void, addPacket, (const RegularQuicPacket&, uint64_t)); + MOCK_METHOD( + void, addPacket, - 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( + (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, addCongestionMetricUpdate, - void(uint64_t, uint64_t, std::string, std::string, std::string)); - MOCK_METHOD2( + (uint64_t, uint64_t, std::string, std::string, std::string)); + MOCK_METHOD( + void, addPacingMetricUpdate, - void(uint64_t, std::chrono::microseconds)); - MOCK_METHOD3( + (uint64_t, std::chrono::microseconds)); + MOCK_METHOD( + void, addPacingObservation, - 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( + (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, addMetricUpdate, - void( - std::chrono::microseconds, - std::chrono::microseconds, - std::chrono::microseconds, - std::chrono::microseconds)); - MOCK_METHOD3( + (std::chrono::microseconds, + std::chrono::microseconds, + std::chrono::microseconds, + std::chrono::microseconds)); + MOCK_METHOD( + void, addStreamStateUpdate, - void( - quic::StreamId, - std::string, - folly::Optional)); - MOCK_METHOD2( + (quic::StreamId, + std::string, + folly::Optional)); + MOCK_METHOD( + void, addBandwidthEstUpdate, - 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)); - MOCK_METHOD1(setScid, void(folly::Optional)); - MOCK_METHOD3(addPriorityUpdate, void(quic::StreamId, uint8_t, bool)); + (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)); + MOCK_METHOD(void, setScid, (folly::Optional)); + MOCK_METHOD(void, addPriorityUpdate, (quic::StreamId, uint8_t, bool)); }; } // namespace quic::test diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp index 40150868c..de5d7217d 100644 --- a/quic/loss/test/QuicLossFunctionsTest.cpp +++ b/quic/loss/test/QuicLossFunctionsTest.cpp @@ -63,9 +63,9 @@ namespace test { class MockLossTimeout { public: - MOCK_METHOD0(cancelLossTimeout, void()); - MOCK_METHOD1(scheduleLossTimeout, void(std::chrono::milliseconds)); - MOCK_METHOD0(isLossTimeoutScheduled, bool()); + MOCK_METHOD(void, cancelLossTimeout, ()); + MOCK_METHOD(void, scheduleLossTimeout, (std::chrono::milliseconds)); + MOCK_METHOD(bool, isLossTimeoutScheduled, ()); }; enum class PacketType { @@ -2547,7 +2547,7 @@ TEST_F(QuicLossFunctionsTest, LossVisitorDSRTest) { EXPECT_FALSE(conn->streamManager->writableDSRStreams().empty()); } -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicLossFunctionsTests, QuicLossFunctionsTest, Values( diff --git a/quic/server/handshake/test/ServerHandshakeTest.cpp b/quic/server/handshake/test/ServerHandshakeTest.cpp index 8adcc55e6..bc26812a2 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; - GMOCK_METHOD0_(, noexcept, , onCryptoEventAvailable, void()); + MOCK_METHOD(void, onCryptoEventAvailable, (), (noexcept)); }; struct TestingServerConnectionState : public QuicServerConnectionState { diff --git a/quic/server/test/Mocks.h b/quic/server/test/Mocks.h index d7f378932..ce676cc9f 100644 --- a/quic/server/test/Mocks.h +++ b/quic/server/test/Mocks.h @@ -18,20 +18,11 @@ 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(*this) @@ -54,7 +45,6 @@ class MockQuicServerTransportFactory : public QuicServerTransportFactory { return _make(evb, socket, addr, ctx); } -#if defined(MOCK_METHOD) MOCK_METHOD( (QuicServerTransport::Ptr), _make, @@ -63,42 +53,30 @@ class MockQuicServerTransportFactory : public QuicServerTransportFactory { const folly::SocketAddress&, std::shared_ptr), (noexcept)); -#else - GMOCK_METHOD4_( - , - noexcept, - , - _make, - QuicServerTransport::Ptr( - folly::EventBase* evb, - std::unique_ptr& sock, - const folly::SocketAddress&, - std::shared_ptr)); -#endif }; class MockWorkerCallback : public QuicServerWorker::WorkerCallback { public: ~MockWorkerCallback() = default; - MOCK_METHOD1(handleWorkerError, void(LocalErrorCode)); + MOCK_METHOD(void, handleWorkerError, (LocalErrorCode)); - MOCK_METHOD5( + MOCK_METHOD( + void, routeDataToWorkerLong, - void( - const folly::SocketAddress&, - std::unique_ptr&, - std::unique_ptr&, - folly::Optional, - bool isForwardedData)); + (const folly::SocketAddress&, + std::unique_ptr&, + std::unique_ptr&, + folly::Optional, + bool isForwardedData)); - MOCK_METHOD5( + MOCK_METHOD( + void, routeDataToWorkerShort, - void( - const folly::SocketAddress&, - std::unique_ptr&, - std::unique_ptr&, - folly::Optional, - bool isForwardedData)); + (const folly::SocketAddress&, + std::unique_ptr&, + std::unique_ptr&, + folly::Optional, + bool isForwardedData)); void routeDataToWorker( const folly::SocketAddress& client, @@ -124,14 +102,13 @@ class MockQuicUDPSocketFactory : public QuicUDPSocketFactory { std::unique_ptr make(folly::EventBase* evb, int fd) { return std::unique_ptr(_make(evb, fd)); } - MOCK_METHOD2(_make, folly::AsyncUDPSocket*(folly::EventBase*, int)); + MOCK_METHOD(folly::AsyncUDPSocket*, _make, (folly::EventBase*, int)); }; class MockRoutingCallback : public QuicServerTransport::RoutingCallback { public: ~MockRoutingCallback() override = default; -#if defined(MOCK_METHOD) MOCK_METHOD( (void), onConnectionIdAvailable, @@ -149,29 +126,6 @@ class MockRoutingCallback : public QuicServerTransport::RoutingCallback { const QuicServerTransport::SourceIdentity&, const std::vector&), (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& connIdData)); -#endif }; class MockHandshakeFinishedCallback @@ -179,13 +133,8 @@ 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 cb17d9f74..662d741f2 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: - 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*)); + 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)); }; TEST_F(QuicServerWorkerTest, AcceptObserver) { diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp index 0cbce1adc..18e5e8353 100644 --- a/quic/server/test/QuicServerTransportTest.cpp +++ b/quic/server/test/QuicServerTransportTest.cpp @@ -1734,7 +1734,7 @@ class QuicServerTransportAllowMigrationTest } }; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicServerTransportMigrationTests, QuicServerTransportAllowMigrationTest, Values( @@ -3683,7 +3683,7 @@ class QuicServerTransportPendingDataTest } }; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicServerTransportPendingDataTests, QuicServerTransportPendingDataTest, Values( @@ -3942,7 +3942,7 @@ class QuicServerTransportHandshakeTest std::vector expectedSourceToken_; }; -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicServerTransportHandshakeTests, QuicServerTransportHandshakeTest, Values( diff --git a/quic/state/test/AckHandlersTest.cpp b/quic/state/test/AckHandlersTest.cpp index 86c849369..b20bf3259 100644 --- a/quic/state/test/AckHandlersTest.cpp +++ b/quic/state/test/AckHandlersTest.cpp @@ -5235,7 +5235,7 @@ TEST_F(AckEventForAppDataTest, AckEventRetransMultipleDupack) { } } -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( AckHandlersTests, AckHandlersTest, Values( diff --git a/quic/state/test/MockQuicStats.h b/quic/state/test/MockQuicStats.h index 0a43bba34..51fe0cd89 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_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)); - 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()); + 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)); + 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, ()); }; class MockQuicStatsFactory : public QuicTransportStatsCallbackFactory { public: ~MockQuicStatsFactory() override = default; - MOCK_METHOD0(make, std::unique_ptr()); + MOCK_METHOD(std::unique_ptr, make, ()); }; } // namespace quic diff --git a/quic/state/test/Mocks.h b/quic/state/test/Mocks.h index f832ee882..85a594225 100644 --- a/quic/state/test/Mocks.h +++ b/quic/state/test/Mocks.h @@ -16,59 +16,62 @@ namespace test { class MockCongestionController : public CongestionController { public: ~MockCongestionController() override {} - MOCK_METHOD1(onRemoveBytesFromInflight, void(uint64_t)); - MOCK_METHOD1(onPacketSent, void(const OutstandingPacket&)); - MOCK_METHOD2( + MOCK_METHOD(void, onRemoveBytesFromInflight, (uint64_t)); + MOCK_METHOD(void, onPacketSent, (const OutstandingPacket&)); + MOCK_METHOD( + void, onPacketAckOrLoss, - 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)); + (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)); }; class MockPacer : public Pacer { public: - MOCK_METHOD3( + MOCK_METHOD( + void, refreshPacingRate, - 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( + (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, getTimeUntilNextWrite, - 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)); + (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)); }; class MockPendingPathRateLimiter : public PendingPathRateLimiter { public: MockPendingPathRateLimiter() : PendingPathRateLimiter(0) {} - MOCK_METHOD1(onPacketSent, void(uint64_t)); - GMOCK_METHOD2_( - , - noexcept, - , + MOCK_METHOD(void, onPacketSent, (uint64_t)); + MOCK_METHOD( + uint64_t, currentCredit, - uint64_t(TimePoint, std::chrono::microseconds)); + (TimePoint, std::chrono::microseconds), + (noexcept)); }; class MockQuicStreamPrioritiesObserver : public QuicStreamPrioritiesObserver { public: - MOCK_METHOD0(onStreamPrioritiesChange, void()); + MOCK_METHOD(void, onStreamPrioritiesChange, ()); }; } // namespace test } // namespace quic diff --git a/quic/state/test/QuicStateFunctionsTest.cpp b/quic/state/test/QuicStateFunctionsTest.cpp index cbf3d619c..0bea1c14f 100644 --- a/quic/state/test/QuicStateFunctionsTest.cpp +++ b/quic/state/test/QuicStateFunctionsTest.cpp @@ -82,7 +82,7 @@ TEST_P(UpdateLargestReceivedPacketNumTest, ReceiveOld) { currentLargestReceived); } -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( UpdateLargestReceivedPacketNumTests, UpdateLargestReceivedPacketNumTest, Values( @@ -506,7 +506,7 @@ TEST_P( EXPECT_FALSE(verifyToScheduleAckTimeout(conn)); } -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( UpdateAckStateTests, UpdateAckStateTest, Values( @@ -874,7 +874,7 @@ TEST_P(QuicStateFunctionsTest, CloseTranportStateChange) { EXPECT_TRUE(conn.pendingEvents.closeTransport); } -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( QuicStateFunctionsTests, QuicStateFunctionsTest, Values(