lib/mvfst
1
0
Fork 0
mirror of https://github.com/facebookincubator/mvfst.git synced 2025-08-01 01:44:22 +03:00
Code Activity

Migrate from googletest 1.8 to googletest 1.10 (#67)

Browse Source 
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
This commit is contained in:
Dimitri Bouche
2022-03-03 03:46:03 -08:00
committed by Facebook GitHub Bot
parent 11ffe17c26
commit 715dec85be
35 changed files with 547 additions and 776 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build/fbcode_builder/manifests/mvfst
View File

@ -25,7 +25,7 @@ folly
fizz fizz
[dependencies.all(test=on, not(os=windows))] [dependencies.all(test=on, not(os=windows))]
googletest_1_8 googletest
[shipit.pathmap] [shipit.pathmap]
fbcode/quic/public_root = . fbcode/quic/public_root = .

2
build/fbcode_builder/manifests/proxygen
View File

@ -32,7 +32,7 @@ wangle
mvfst mvfst
[dependencies.test=on] [dependencies.test=on]
googletest_1_8 googletest
[shipit.pathmap] [shipit.pathmap]
fbcode/proxygen/public_tld = . fbcode/proxygen/public_tld = .

2
build_helper.sh
View File

@ -210,7 +210,7 @@ function setup_googletest() {
fi fi
cd "$GTEST_DIR" cd "$GTEST_DIR"
git fetch --tags git fetch --tags
git checkout release-1.8.0 git checkout release-1.10.0
echo -e "${COLOR_GREEN}Building googletest ${COLOR_OFF}" echo -e "${COLOR_GREEN}Building googletest ${COLOR_OFF}"
mkdir -p "$GTEST_BUILD_DIR" mkdir -p "$GTEST_BUILD_DIR"
cd "$GTEST_BUILD_DIR" || exit cd "$GTEST_BUILD_DIR" || exit

4
cmake/QuicTest.cmake
View File

@ -6,8 +6,8 @@
include(CTest) include(CTest)
if(BUILD_TESTS) if(BUILD_TESTS)
find_package(GMock 1.8.0 MODULE REQUIRED) find_package(GMock 1.10.0 MODULE REQUIRED)
find_package(GTest 1.8.0 MODULE REQUIRED) find_package(GTest 1.10.0 MODULE REQUIRED)
endif() endif()
function(quic_add_test) function(quic_add_test)

394
quic/api/test/MockQuicSocket.h
View File

@ -23,93 +23,112 @@ class MockQuicSocket : public QuicSocket {
ConnectionCallback* connCb) ConnectionCallback* connCb)
: setupCb_(setupCb), connCb_(connCb) {} : setupCb_(setupCb), connCb_(connCb) {}
MOCK_CONST_METHOD0(good, bool()); MOCK_METHOD(bool, good, (), (const));
MOCK_CONST_METHOD0(replaySafe, bool()); MOCK_METHOD(bool, replaySafe, (), (const));
MOCK_CONST_METHOD0(error, bool()); MOCK_METHOD(bool, error, (), (const));
MOCK_METHOD1(close, void(folly::Optional<QuicError>)); MOCK_METHOD(void, close, (folly::Optional<QuicError>));
MOCK_METHOD0(closeGracefully, void()); MOCK_METHOD(void, closeGracefully, ());
MOCK_METHOD1(closeNow, void(folly::Optional<QuicError>)); MOCK_METHOD(void, closeNow, (folly::Optional<QuicError>));
MOCK_CONST_METHOD0( MOCK_METHOD(
folly::Optional<quic::ConnectionId>,
getClientConnectionId, getClientConnectionId,
folly::Optional<quic::ConnectionId>()); (),
MOCK_CONST_METHOD0(getTransportSettings, const TransportSettings&()); (const));
MOCK_CONST_METHOD0( MOCK_METHOD(const TransportSettings&, getTransportSettings, (), (const));
MOCK_METHOD(
folly::Optional<quic::ConnectionId>,
getServerConnectionId, getServerConnectionId,
folly::Optional<quic::ConnectionId>()); (),
MOCK_CONST_METHOD0( (const));
MOCK_METHOD(
folly::Optional<quic::ConnectionId>,
getClientChosenDestConnectionId, getClientChosenDestConnectionId,
folly::Optional<quic::ConnectionId>()); (),
MOCK_CONST_METHOD0(getPeerAddress, const folly::SocketAddress&()); (const));
MOCK_CONST_METHOD0(getOriginalPeerAddress, const folly::SocketAddress&()); MOCK_METHOD(const folly::SocketAddress&, getPeerAddress, (), (const));
MOCK_CONST_METHOD0(getLocalAddress, const folly::SocketAddress&()); MOCK_METHOD(const folly::SocketAddress&, getOriginalPeerAddress, (), (const));
MOCK_CONST_METHOD0(getEventBase, folly::EventBase*()); MOCK_METHOD(const folly::SocketAddress&, getLocalAddress, (), (const));
MOCK_CONST_METHOD1( MOCK_METHOD(folly::EventBase*, getEventBase, (), (const));
MOCK_METHOD(
(folly::Expected<size_t, LocalErrorCode>),
getStreamReadOffset, getStreamReadOffset,
folly::Expected<size_t, LocalErrorCode>(StreamId)); (StreamId),
MOCK_CONST_METHOD1( (const));
MOCK_METHOD(
(folly::Expected<size_t, LocalErrorCode>),
getStreamWriteOffset, getStreamWriteOffset,
folly::Expected<size_t, LocalErrorCode>(StreamId)); (StreamId),
MOCK_CONST_METHOD1( (const));
MOCK_METHOD(
(folly::Expected<size_t, LocalErrorCode>),
getStreamWriteBufferedBytes, getStreamWriteBufferedBytes,
folly::Expected<size_t, LocalErrorCode>(StreamId)); (StreamId),
MOCK_CONST_METHOD0(getTransportInfo, QuicSocket::TransportInfo()); (const));
MOCK_CONST_METHOD1( MOCK_METHOD(QuicSocket::TransportInfo, getTransportInfo, (), (const));
MOCK_METHOD(
(folly::Expected<QuicSocket::StreamTransportInfo, LocalErrorCode>),
getStreamTransportInfo, getStreamTransportInfo,
folly::Expected<QuicSocket::StreamTransportInfo, LocalErrorCode>( (StreamId),
StreamId)); (const));
MOCK_CONST_METHOD0(getAppProtocol, folly::Optional<std::string>()); MOCK_METHOD(folly::Optional<std::string>, getAppProtocol, (), (const));
MOCK_METHOD2(setReceiveWindow, void(StreamId, size_t)); MOCK_METHOD(void, setReceiveWindow, (StreamId, size_t));
MOCK_METHOD3(setSendBuffer, void(StreamId, size_t, size_t)); MOCK_METHOD(void, setSendBuffer, (StreamId, size_t, size_t));
MOCK_CONST_METHOD0(getConnectionBufferAvailable, uint64_t()); MOCK_METHOD(uint64_t, getConnectionBufferAvailable, (), (const));
MOCK_CONST_METHOD0( MOCK_METHOD(
(folly::Expected<FlowControlState, LocalErrorCode>),
getConnectionFlowControl, getConnectionFlowControl,
folly::Expected<FlowControlState, LocalErrorCode>()); (),
MOCK_CONST_METHOD1( (const));
MOCK_METHOD(
(folly::Expected<FlowControlState, LocalErrorCode>),
getStreamFlowControl, getStreamFlowControl,
folly::Expected<FlowControlState, LocalErrorCode>(StreamId)); (StreamId),
MOCK_METHOD0(unsetAllReadCallbacks, void()); (const));
MOCK_METHOD0(unsetAllPeekCallbacks, void()); MOCK_METHOD(void, unsetAllReadCallbacks, ());
MOCK_METHOD0(unsetAllDeliveryCallbacks, void()); MOCK_METHOD(void, unsetAllPeekCallbacks, ());
MOCK_METHOD1(cancelDeliveryCallbacksForStream, void(StreamId)); MOCK_METHOD(void, unsetAllDeliveryCallbacks, ());
MOCK_METHOD2( MOCK_METHOD(void, cancelDeliveryCallbacksForStream, (StreamId));
MOCK_METHOD(
void,
cancelDeliveryCallbacksForStream, cancelDeliveryCallbacksForStream,
void(StreamId, uint64_t offset)); (StreamId, uint64_t offset));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setConnectionFlowControlWindow, setConnectionFlowControlWindow,
folly::Expected<folly::Unit, LocalErrorCode>(uint64_t)); (uint64_t));
MOCK_METHOD2( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setStreamFlowControlWindow, setStreamFlowControlWindow,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, uint64_t)); (StreamId, uint64_t));
MOCK_METHOD1(setTransportSettings, void(TransportSettings)); MOCK_METHOD(void, setTransportSettings, (TransportSettings));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setMaxPacingRate, setMaxPacingRate,
folly::Expected<folly::Unit, LocalErrorCode>(uint64_t)); (uint64_t));
folly::Expected<folly::Unit, LocalErrorCode> folly::Expected<folly::Unit, LocalErrorCode>
setKnob(uint64_t knobSpace, uint64_t knobId, Buf knobBlob) override { setKnob(uint64_t knobSpace, uint64_t knobId, Buf knobBlob) override {
SharedBuf sharedBlob(knobBlob.release()); SharedBuf sharedBlob(knobBlob.release());
return setKnob(knobSpace, knobId, sharedBlob); return setKnob(knobSpace, knobId, sharedBlob);
} }
MOCK_METHOD3( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setKnob, setKnob,
folly::Expected<folly::Unit, LocalErrorCode>( (uint64_t, uint64_t, SharedBuf));
uint64_t, MOCK_METHOD(bool, isKnobSupported, (), (const));
uint64_t, MOCK_METHOD(
SharedBuf)); (folly::Expected<folly::Unit, LocalErrorCode>),
MOCK_CONST_METHOD0(isKnobSupported, bool());
MOCK_METHOD3(
setStreamPriority, setStreamPriority,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, uint8_t, bool)); (StreamId, uint8_t, bool));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<Priority, LocalErrorCode>),
getStreamPriority, getStreamPriority,
folly::Expected<Priority, LocalErrorCode>(StreamId)); (StreamId));
MOCK_METHOD3( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setReadCallback, setReadCallback,
folly::Expected<folly::Unit, LocalErrorCode>( (StreamId, ReadCallback*, folly::Optional<ApplicationErrorCode> err));
StreamId, MOCK_METHOD(void, setConnectionSetupCallback, (ConnectionSetupCallback*));
ReadCallback*, MOCK_METHOD(void, setConnectionCallback, (ConnectionCallback*));
folly::Optional<ApplicationErrorCode> err));
MOCK_METHOD1(setConnectionSetupCallback, void(ConnectionSetupCallback*));
MOCK_METHOD1(setConnectionCallback, void(ConnectionCallback*));
void setEarlyDataAppParamsFunctions( void setEarlyDataAppParamsFunctions(
folly::Function<bool(const folly::Optional<std::string>&, const Buf&) folly::Function<bool(const folly::Optional<std::string>&, const Buf&)
const> validator, const> validator,
@ -117,17 +136,18 @@ class MockQuicSocket : public QuicSocket {
earlyDataAppParamsValidator_ = std::move(validator); earlyDataAppParamsValidator_ = std::move(validator);
earlyDataAppParamsGetter_ = std::move(getter); earlyDataAppParamsGetter_ = std::move(getter);
} }
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
pauseRead, pauseRead,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId)); (StreamId));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
resumeRead, resumeRead,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId)); (StreamId));
MOCK_METHOD2( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
stopSending, stopSending,
folly::Expected<folly::Unit, LocalErrorCode>( (StreamId, ApplicationErrorCode));
StreamId,
ApplicationErrorCode));
folly::Expected<std::pair<Buf, bool>, LocalErrorCode> read( folly::Expected<std::pair<Buf, bool>, LocalErrorCode> read(
StreamId id, StreamId id,
size_t maxRead) override { size_t maxRead) override {
@ -140,16 +160,17 @@ class MockQuicSocket : public QuicSocket {
} }
using ReadResult = using ReadResult =
folly::Expected<std::pair<folly::IOBuf*, bool>, LocalErrorCode>; folly::Expected<std::pair<folly::IOBuf*, bool>, LocalErrorCode>;
MOCK_METHOD2(readNaked, ReadResult(StreamId, size_t)); MOCK_METHOD(ReadResult, readNaked, (StreamId, size_t));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<StreamId, LocalErrorCode>),
createBidirectionalStream, createBidirectionalStream,
folly::Expected<StreamId, LocalErrorCode>(bool)); (bool));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<StreamId, LocalErrorCode>),
createUnidirectionalStream, createUnidirectionalStream,
folly::Expected<StreamId, LocalErrorCode>(bool)); (bool));
MOCK_CONST_METHOD0(getNumOpenableBidirectionalStreams, uint64_t()); MOCK_METHOD(uint64_t, getNumOpenableBidirectionalStreams, (), (const));
MOCK_CONST_METHOD0(getNumOpenableUnidirectionalStreams, uint64_t()); MOCK_METHOD(uint64_t, getNumOpenableUnidirectionalStreams, (), (const));
#if defined(MOCK_METHOD)
MOCK_METHOD((bool), isClientStream, (StreamId), (noexcept)); MOCK_METHOD((bool), isClientStream, (StreamId), (noexcept));
MOCK_METHOD((bool), isServerStream, (StreamId), (noexcept)); MOCK_METHOD((bool), isServerStream, (StreamId), (noexcept));
MOCK_METHOD((StreamInitiator), getStreamInitiator, (StreamId), (noexcept)); MOCK_METHOD((StreamInitiator), getStreamInitiator, (StreamId), (noexcept));
@ -160,136 +181,131 @@ class MockQuicSocket : public QuicSocket {
getStreamDirectionality, getStreamDirectionality,
(StreamId), (StreamId),
(noexcept)); (noexcept));
#else MOCK_METHOD(
GMOCK_METHOD1_(, noexcept, , isClientStream, bool(StreamId)); (folly::Expected<folly::Unit, LocalErrorCode>),
GMOCK_METHOD1_(, noexcept, , isServerStream, bool(StreamId));
GMOCK_METHOD1_(, noexcept, , getStreamInitiator, StreamInitiator(StreamId));
GMOCK_METHOD1_(, noexcept, , isBidirectionalStream, bool(StreamId));
GMOCK_METHOD1_(, noexcept, , isUnidirectionalStream, bool(StreamId));
GMOCK_METHOD1_(
,
noexcept,
,
getStreamDirectionality,
StreamDirectionality(StreamId));
#endif
MOCK_METHOD1(
notifyPendingWriteOnConnection, notifyPendingWriteOnConnection,
folly::Expected<folly::Unit, LocalErrorCode>(WriteCallback*)); (WriteCallback*));
MOCK_METHOD2( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
notifyPendingWriteOnStream, notifyPendingWriteOnStream,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, WriteCallback*)); (StreamId, WriteCallback*));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
unregisterStreamWriteCallback, unregisterStreamWriteCallback,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId)); (StreamId));
MOCK_METHOD3( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
registerTxCallback, registerTxCallback,
folly::Expected<folly::Unit, LocalErrorCode>( (const StreamId, const uint64_t, ByteEventCallback*));
const StreamId, MOCK_METHOD(
const uint64_t, (folly::Expected<folly::Unit, LocalErrorCode>),
ByteEventCallback*));
MOCK_METHOD4(
registerByteEventCallback, registerByteEventCallback,
folly::Expected<folly::Unit, LocalErrorCode>( (const ByteEvent::Type,
const ByteEvent::Type, const StreamId,
const StreamId, const uint64_t,
const uint64_t, ByteEventCallback*));
ByteEventCallback*)); MOCK_METHOD(
MOCK_METHOD2( void,
cancelByteEventCallbacksForStream, cancelByteEventCallbacksForStream,
void(const StreamId id, const folly::Optional<uint64_t>& offset)); (const StreamId id, const folly::Optional<uint64_t>& offset));
MOCK_METHOD3( MOCK_METHOD(
void,
cancelByteEventCallbacksForStream, cancelByteEventCallbacksForStream,
void( (const ByteEvent::Type,
const ByteEvent::Type, const StreamId id,
const StreamId id, const folly::Optional<uint64_t>& offset));
const folly::Optional<uint64_t>& offset)); MOCK_METHOD(void, cancelAllByteEventCallbacks, ());
MOCK_METHOD0(cancelAllByteEventCallbacks, void()); MOCK_METHOD(void, cancelByteEventCallbacks, (const ByteEvent::Type));
MOCK_METHOD1(cancelByteEventCallbacks, void(const ByteEvent::Type)); MOCK_METHOD(
MOCK_CONST_METHOD1( size_t,
getNumByteEventCallbacksForStream, getNumByteEventCallbacksForStream,
size_t(const StreamId id)); (const StreamId id),
MOCK_CONST_METHOD2( (const));
MOCK_METHOD(
size_t,
getNumByteEventCallbacksForStream, getNumByteEventCallbacksForStream,
size_t(const ByteEvent::Type, const StreamId)); (const ByteEvent::Type, const StreamId),
(const));
folly::Expected<folly::Unit, LocalErrorCode> folly::Expected<folly::Unit, LocalErrorCode>
writeChain(StreamId id, Buf data, bool eof, ByteEventCallback* cb) override { writeChain(StreamId id, Buf data, bool eof, ByteEventCallback* cb) override {
SharedBuf sharedData(data.release()); SharedBuf sharedData(data.release());
return writeChain(id, sharedData, eof, cb); return writeChain(id, sharedData, eof, cb);
} }
MOCK_METHOD4( MOCK_METHOD(
WriteResult,
writeChain, writeChain,
WriteResult(StreamId, SharedBuf, bool, ByteEventCallback*)); (StreamId, SharedBuf, bool, ByteEventCallback*));
MOCK_METHOD4( MOCK_METHOD(
WriteResult,
writeBufMeta, writeBufMeta,
WriteResult(StreamId, const BufferMeta&, bool, ByteEventCallback*)); (StreamId, const BufferMeta&, bool, ByteEventCallback*));
MOCK_METHOD2( MOCK_METHOD(
WriteResult,
setDSRPacketizationRequestSenderRef, setDSRPacketizationRequestSenderRef,
WriteResult( (StreamId, const std::unique_ptr<DSRPacketizationRequestSender>&));
StreamId,
const std::unique_ptr<DSRPacketizationRequestSender>&));
WriteResult setDSRPacketizationRequestSender( WriteResult setDSRPacketizationRequestSender(
StreamId streamId, StreamId streamId,
std::unique_ptr<DSRPacketizationRequestSender> sender) override { std::unique_ptr<DSRPacketizationRequestSender> sender) override {
return setDSRPacketizationRequestSenderRef(streamId, sender); return setDSRPacketizationRequestSenderRef(streamId, sender);
} }
MOCK_METHOD3( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
registerDeliveryCallback, registerDeliveryCallback,
folly::Expected<folly::Unit, LocalErrorCode>( (StreamId, uint64_t, ByteEventCallback*));
StreamId,
uint64_t,
ByteEventCallback*));
MOCK_METHOD1(shutdownWrite, folly::Optional<LocalErrorCode>(StreamId)); MOCK_METHOD(folly::Optional<LocalErrorCode>, shutdownWrite, (StreamId));
MOCK_METHOD2( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
resetStream, resetStream,
folly::Expected<folly::Unit, LocalErrorCode>( (StreamId, ApplicationErrorCode));
StreamId, MOCK_METHOD(
ApplicationErrorCode)); (folly::Expected<folly::Unit, LocalErrorCode>),
MOCK_METHOD2(
maybeResetStreamFromReadError, maybeResetStreamFromReadError,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, QuicErrorCode)); (StreamId, QuicErrorCode));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setPingCallback, setPingCallback,
folly::Expected<folly::Unit, LocalErrorCode>(PingCallback*)); (PingCallback*));
MOCK_METHOD1(sendPing, void(std::chrono::milliseconds)); MOCK_METHOD(void, sendPing, (std::chrono::milliseconds));
MOCK_CONST_METHOD0(getState, const QuicConnectionStateBase*()); MOCK_METHOD(const QuicConnectionStateBase*, getState, (), (const));
MOCK_METHOD0(isDetachable, bool()); MOCK_METHOD(bool, isDetachable, ());
MOCK_METHOD1(attachEventBase, void(folly::EventBase*)); MOCK_METHOD(void, attachEventBase, (folly::EventBase*));
MOCK_METHOD0(detachEventBase, void()); MOCK_METHOD(void, detachEventBase, ());
MOCK_METHOD1(setControlStream, folly::Optional<LocalErrorCode>(StreamId)); MOCK_METHOD(folly::Optional<LocalErrorCode>, setControlStream, (StreamId));
MOCK_METHOD2( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setPeekCallback, setPeekCallback,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, PeekCallback*)); (StreamId, PeekCallback*));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
pausePeek, pausePeek,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId)); (StreamId));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
resumePeek, resumePeek,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId)); (StreamId));
MOCK_METHOD2( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
peek, peek,
folly::Expected<folly::Unit, LocalErrorCode>( (StreamId,
StreamId, const folly::Function<void(StreamId, const folly::Range<PeekIterator>&)
const folly::Function< const>&));
void(StreamId, const folly::Range<PeekIterator>&) const>&));
MOCK_METHOD3( MOCK_METHOD(
consume, (folly::Expected<
folly::Expected<
folly::Unit, folly::Unit,
std::pair<LocalErrorCode, folly::Optional<uint64_t>>>( std::pair<LocalErrorCode, folly::Optional<uint64_t>>>),
StreamId,
uint64_t,
size_t));
MOCK_METHOD2(
consume, consume,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, size_t)); (StreamId, uint64_t, size_t));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
consume,
(StreamId, size_t));
MOCK_METHOD1(setCongestionControl, void(CongestionControlType)); MOCK_METHOD(void, setCongestionControl, (CongestionControlType));
ConnectionSetupCallback* setupCb_; ConnectionSetupCallback* setupCb_;
ConnectionCallback* connCb_; ConnectionCallback* connCb_;
@ -298,28 +314,32 @@ class MockQuicSocket : public QuicSocket {
earlyDataAppParamsValidator_; earlyDataAppParamsValidator_;
folly::Function<Buf()> earlyDataAppParamsGetter_; folly::Function<Buf()> earlyDataAppParamsGetter_;
MOCK_METHOD1(addObserver, void(Observer*)); MOCK_METHOD(void, addObserver, (Observer*));
MOCK_METHOD1(removeObserver, bool(Observer*)); MOCK_METHOD(bool, removeObserver, (Observer*));
MOCK_CONST_METHOD0(getObservers, const ObserverVec&()); MOCK_METHOD(const ObserverVec&, getObservers, (), (const));
MOCK_METHOD2( MOCK_METHOD(
void,
resetNonControlStreams, resetNonControlStreams,
void(ApplicationErrorCode, folly::StringPiece)); (ApplicationErrorCode, folly::StringPiece));
MOCK_CONST_METHOD0(getConnectionsStats, QuicConnectionStats()); MOCK_METHOD(QuicConnectionStats, getConnectionsStats, (), (const));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setDatagramCallback, setDatagramCallback,
folly::Expected<folly::Unit, LocalErrorCode>(DatagramCallback*)); (DatagramCallback*));
MOCK_CONST_METHOD0(getDatagramSizeLimit, uint16_t()); MOCK_METHOD(uint16_t, getDatagramSizeLimit, (), (const));
folly::Expected<folly::Unit, LocalErrorCode> writeDatagram( folly::Expected<folly::Unit, LocalErrorCode> writeDatagram(
Buf data) override { Buf data) override {
SharedBuf sharedData(data.release()); SharedBuf sharedData(data.release());
return writeDatagram(sharedData); return writeDatagram(sharedData);
} }
MOCK_METHOD1(writeDatagram, WriteResult(SharedBuf)); MOCK_METHOD(WriteResult, writeDatagram, (SharedBuf));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<std::vector<ReadDatagram>, LocalErrorCode>),
readDatagrams, readDatagrams,
folly::Expected<std::vector<ReadDatagram>, LocalErrorCode>(size_t)); (size_t));
MOCK_METHOD1( MOCK_METHOD(
(folly::Expected<std::vector<Buf>, LocalErrorCode>),
readDatagramBufs, readDatagramBufs,
folly::Expected<std::vector<Buf>, LocalErrorCode>(size_t)); (size_t));
}; };
} // namespace quic } // namespace quic

251
quic/api/test/Mocks.h
View File

@ -34,97 +34,59 @@ class MockFrameScheduler : public FrameScheduler {
return _scheduleFramesForPacket(&builderIn, writableBytes); return _scheduleFramesForPacket(&builderIn, writableBytes);
} }
#if defined(MOCK_METHOD)
MOCK_METHOD((bool), hasData, (), (const)); MOCK_METHOD((bool), hasData, (), (const));
#else MOCK_METHOD(
GMOCK_METHOD0_(, const, , hasData, bool()); SchedulingResult,
#endif
MOCK_METHOD2(
_scheduleFramesForPacket, _scheduleFramesForPacket,
SchedulingResult(PacketBuilderInterface*, uint32_t)); (PacketBuilderInterface*, uint32_t));
}; };
class MockReadCallback : public QuicSocket::ReadCallback { class MockReadCallback : public QuicSocket::ReadCallback {
public: public:
~MockReadCallback() override = default; ~MockReadCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), readAvailable, (StreamId), (noexcept)); MOCK_METHOD((void), readAvailable, (StreamId), (noexcept));
MOCK_METHOD((void), readError, (StreamId, QuicError), (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 { class MockPeekCallback : public QuicSocket::PeekCallback {
public: public:
~MockPeekCallback() override = default; ~MockPeekCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD( MOCK_METHOD(
(void), (void),
onDataAvailable, onDataAvailable,
(StreamId, const folly::Range<PeekIterator>&), (StreamId, const folly::Range<PeekIterator>&),
(noexcept)); (noexcept));
MOCK_METHOD((void), peekError, (StreamId, QuicError), (noexcept)); MOCK_METHOD((void), peekError, (StreamId, QuicError), (noexcept));
#else
GMOCK_METHOD2_(
,
noexcept,
,
onDataAvailable,
void(StreamId, const folly::Range<PeekIterator>&));
GMOCK_METHOD2_(, noexcept, , peekError, void(StreamId, QuicError));
#endif
}; };
class MockDatagramCallback : public QuicSocket::DatagramCallback { class MockDatagramCallback : public QuicSocket::DatagramCallback {
public: public:
~MockDatagramCallback() override = default; ~MockDatagramCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onDatagramsAvailable, (), (noexcept)); MOCK_METHOD((void), onDatagramsAvailable, (), (noexcept));
#else
GMOCK_METHOD0_(, noexcept, , onDatagramsAvailable, void());
#endif
}; };
class MockWriteCallback : public QuicSocket::WriteCallback { class MockWriteCallback : public QuicSocket::WriteCallback {
public: public:
~MockWriteCallback() override = default; ~MockWriteCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onStreamWriteReady, (StreamId, uint64_t), (noexcept)); MOCK_METHOD((void), onStreamWriteReady, (StreamId, uint64_t), (noexcept));
MOCK_METHOD((void), onConnectionWriteReady, (uint64_t), (noexcept)); MOCK_METHOD((void), onConnectionWriteReady, (uint64_t), (noexcept));
MOCK_METHOD((void), onStreamWriteError, (StreamId, QuicError), (noexcept)); MOCK_METHOD((void), onStreamWriteError, (StreamId, QuicError), (noexcept));
MOCK_METHOD((void), onConnectionWriteError, (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 { class MockConnectionSetupCallback : public QuicSocket::ConnectionSetupCallback {
public: public:
~MockConnectionSetupCallback() override = default; ~MockConnectionSetupCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onConnectionSetupError, (QuicError), (noexcept)); MOCK_METHOD((void), onConnectionSetupError, (QuicError), (noexcept));
MOCK_METHOD((void), onReplaySafe, (), (noexcept)); MOCK_METHOD((void), onReplaySafe, (), (noexcept));
MOCK_METHOD((void), onTransportReady, (), (noexcept)); MOCK_METHOD((void), onTransportReady, (), (noexcept));
MOCK_METHOD((void), onFirstPeerPacketProcessed, (), (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 { class MockConnectionCallback : public QuicSocket::ConnectionCallback {
public: public:
~MockConnectionCallback() override = default; ~MockConnectionCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onFlowControlUpdate, (StreamId), (noexcept)); MOCK_METHOD((void), onFlowControlUpdate, (StreamId), (noexcept));
MOCK_METHOD((void), onNewBidirectionalStream, (StreamId), (noexcept)); MOCK_METHOD((void), onNewBidirectionalStream, (StreamId), (noexcept));
MOCK_METHOD((void), onNewUnidirectionalStream, (StreamId), (noexcept)); MOCK_METHOD((void), onNewUnidirectionalStream, (StreamId), (noexcept));
@ -143,33 +105,6 @@ class MockConnectionCallback : public QuicSocket::ConnectionCallback {
onKnobMock, onKnobMock,
(uint64_t, uint64_t, folly::IOBuf*), (uint64_t, uint64_t, folly::IOBuf*),
(noexcept)); (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 { void onKnob(uint64_t knobSpace, uint64_t knobId, Buf knobBlob) override {
onKnobMock(knobSpace, knobId, knobBlob.get()); onKnobMock(knobSpace, knobId, knobBlob.get());
@ -179,18 +114,19 @@ class MockConnectionCallback : public QuicSocket::ConnectionCallback {
class MockDeliveryCallback : public QuicSocket::DeliveryCallback { class MockDeliveryCallback : public QuicSocket::DeliveryCallback {
public: public:
~MockDeliveryCallback() override = default; ~MockDeliveryCallback() override = default;
MOCK_METHOD3( MOCK_METHOD(
void,
onDeliveryAck, onDeliveryAck,
void(StreamId, uint64_t, std::chrono::microseconds)); (StreamId, uint64_t, std::chrono::microseconds));
MOCK_METHOD2(onCanceled, void(StreamId, uint64_t)); MOCK_METHOD(void, onCanceled, (StreamId, uint64_t));
}; };
class MockByteEventCallback : public QuicSocket::ByteEventCallback { class MockByteEventCallback : public QuicSocket::ByteEventCallback {
public: public:
~MockByteEventCallback() override = default; ~MockByteEventCallback() override = default;
MOCK_METHOD1(onByteEventRegistered, void(QuicSocket::ByteEvent)); MOCK_METHOD(void, onByteEventRegistered, (QuicSocket::ByteEvent));
MOCK_METHOD1(onByteEvent, void(QuicSocket::ByteEvent)); MOCK_METHOD(void, onByteEvent, (QuicSocket::ByteEvent));
MOCK_METHOD1(onByteEventCanceled, void(QuicSocket::ByteEvent)); MOCK_METHOD(void, onByteEventCanceled, (QuicSocket::ByteEvent));
static auto getTxMatcher(StreamId id, uint64_t offset) { static auto getTxMatcher(StreamId id, uint64_t offset) {
return AllOf( return AllOf(
@ -248,11 +184,10 @@ class MockQuicTransport : public QuicServerTransport {
customDestructor(); customDestructor();
} }
MOCK_METHOD0(customDestructor, void()); MOCK_METHOD(void, customDestructor, ());
MOCK_CONST_METHOD0(getPeerAddress, const folly::SocketAddress&()); MOCK_METHOD(const folly::SocketAddress&, getPeerAddress, (), (const));
MOCK_CONST_METHOD0(getOriginalPeerAddress, const folly::SocketAddress&()); MOCK_METHOD(const folly::SocketAddress&, getOriginalPeerAddress, (), (const));
#if defined(MOCK_METHOD)
MOCK_METHOD((folly::EventBase*), getEventBase, (), (const)); MOCK_METHOD((folly::EventBase*), getEventBase, (), (const));
MOCK_METHOD((void), accept, (), ()); MOCK_METHOD((void), accept, (), ());
MOCK_METHOD((void), setTransportSettings, (TransportSettings), ()); MOCK_METHOD((void), setTransportSettings, (TransportSettings), ());
@ -302,86 +237,23 @@ class MockQuicTransport : public QuicServerTransport {
(QuicTransportStatsCallback*), (QuicTransportStatsCallback*),
(noexcept)); (noexcept));
MOCK_METHOD((void), setConnectionIdAlgo, (ConnectionIdAlgo*), (noexcept)); MOCK_METHOD((void), setConnectionIdAlgo, (ConnectionIdAlgo*), (noexcept));
#else
GMOCK_METHOD0_(, const, , getEventBase, folly::EventBase*());
GMOCK_METHOD0_(, , , accept, void());
GMOCK_METHOD1_(
,
,
,
setOriginalPeerAddress,
void(const folly::SocketAddress&));
GMOCK_METHOD1_(, , , setTransportSettings, void(TransportSettings));
GMOCK_METHOD1_(, noexcept, , setPacingTimer, void(TimerHighRes::SharedPtr));
GMOCK_METHOD2_(
,
noexcept,
,
onNetworkData,
void(const folly::SocketAddress&, const NetworkData&));
GMOCK_METHOD1_(
,
noexcept,
,
setRoutingCallback,
void(QuicServerTransport::RoutingCallback*));
GMOCK_METHOD1_(
,
noexcept,
,
setHandshakeFinishedCallback,
void(QuicServerTransport::HandshakeFinishedCallback*));
GMOCK_METHOD1_(
,
noexcept,
,
setSupportedVersions,
void(const std::vector<QuicVersion>&));
GMOCK_METHOD1_(
,
noexcept,
,
setServerConnectionIdParams,
void(ServerConnectionIdParams));
GMOCK_METHOD1_(, noexcept, , close, void(folly::Optional<QuicError>));
GMOCK_METHOD1_(, noexcept, , closeNow, void(folly::Optional<QuicError>));
GMOCK_METHOD0_(, const, , hasShutdown, bool());
GMOCK_METHOD0_(
,
const,
,
getClientConnectionId,
folly::Optional<ConnectionId>());
GMOCK_METHOD0_(
,
const,
,
getClientChosenDestConnectionId,
folly::Optional<ConnectionId>());
GMOCK_METHOD1_(
,
noexcept,
,
setTransportStatsCallback,
void(QuicTransportStatsCallback*));
GMOCK_METHOD1_(, noexcept, , setConnectionIdAlgo, void(ConnectionIdAlgo*));
#endif
void onNetworkData( void onNetworkData(
const folly::SocketAddress& peer, const folly::SocketAddress& peer,
NetworkData&& networkData) noexcept override { NetworkData&& networkData) noexcept override {
onNetworkData(peer, networkData); onNetworkData(peer, networkData);
} }
MOCK_METHOD1(setBufAccessor, void(BufAccessor*)); MOCK_METHOD(void, setBufAccessor, (BufAccessor*));
}; };
class MockLoopDetectorCallback : public LoopDetectorCallback { class MockLoopDetectorCallback : public LoopDetectorCallback {
public: public:
~MockLoopDetectorCallback() override = default; ~MockLoopDetectorCallback() override = default;
MOCK_METHOD4( MOCK_METHOD(
void,
onSuspiciousWriteLoops, onSuspiciousWriteLoops,
void(uint64_t, WriteDataReason, NoWriteReason, const std::string&)); (uint64_t, WriteDataReason, NoWriteReason, const std::string&));
MOCK_METHOD2(onSuspiciousReadLoops, void(uint64_t, NoReadReason)); MOCK_METHOD(void, onSuspiciousReadLoops, (uint64_t, NoReadReason));
}; };
class MockObserver : public Observer { class MockObserver : public Observer {
@ -389,7 +261,6 @@ class MockObserver : public Observer {
MockObserver() : Observer(Observer::Config()) {} MockObserver() : Observer(Observer::Config()) {}
MockObserver(const Observer::Config& observerConfig) MockObserver(const Observer::Config& observerConfig)
: Observer(observerConfig) {} : Observer(observerConfig) {}
#if defined(MOCK_METHOD)
MOCK_METHOD((void), observerAttach, (QuicSocket*), (noexcept)); MOCK_METHOD((void), observerAttach, (QuicSocket*), (noexcept));
MOCK_METHOD((void), observerDetach, (QuicSocket*), (noexcept)); MOCK_METHOD((void), observerDetach, (QuicSocket*), (noexcept));
MOCK_METHOD((void), destroy, (QuicSocket*), (noexcept)); MOCK_METHOD((void), destroy, (QuicSocket*), (noexcept));
@ -461,92 +332,6 @@ class MockObserver : public Observer {
streamClosed, streamClosed,
(QuicSocket*, const StreamCloseEvent&), (QuicSocket*, const StreamCloseEvent&),
(noexcept)); (noexcept));
#else
GMOCK_METHOD1_(, noexcept, , observerAttach, void(QuicSocket*));
GMOCK_METHOD1_(, noexcept, , observerDetach, void(QuicSocket*));
GMOCK_METHOD1_(, noexcept, , destroy, void(QuicSocket*));
GMOCK_METHOD2_(, noexcept, , evbAttach, void(QuicSocket*, folly::EventBase*));
GMOCK_METHOD2_(, noexcept, , evbDetach, void(QuicSocket*, folly::EventBase*));
GMOCK_METHOD2_(
,
noexcept,
,
close,
void(QuicSocket*, const folly::Optional<QuicError>&));
GMOCK_METHOD2_(
,
noexcept,
,
startWritingFromAppLimited,
void(QuicSocket*, const AppLimitedEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
packetsWritten,
void(QuicSocket*, const PacketsWrittenEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
appRateLimited,
void(QuicSocket*, const AppLimitedEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
acksProcessed,
void(QuicSocket*, const AcksProcessedEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
packetLossDetected,
void(QuicSocket*, const LossEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
rttSampleGenerated,
void(QuicSocket*, const PacketRTT&));
GMOCK_METHOD1_(, noexcept, , pmtuProbingStarted, void(QuicSocket*));
GMOCK_METHOD2_(
,
noexcept,
,
pmtuBlackholeDetected,
void(QuicSocket*, const PMTUBlackholeEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
pmtuUpperBoundDetected,
void(QuicSocket*, const PMTUUpperBoundEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
spuriousLossDetected,
void(QuicSocket*, const SpuriousLossEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
knobFrameReceived,
void(QuicSocket*, const KnobFrameEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
streamOpened,
void(QuicSocket*, const StreamOpenEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
streamClosed,
void(QuicSocket*, const StreamCloseEvent&));
#endif
static auto getLossPacketNum(PacketNum packetNum) { static auto getLossPacketNum(PacketNum packetNum) {
return testing::Field( return testing::Field(

2
quic/api/test/QuicBatchWriterTest.cpp
View File

@ -627,7 +627,7 @@ TEST_P(QuicBatchWriterTest, InplaceWriterBufResidueCheck) {
EXPECT_EQ(0, rawBuf->headroom()); EXPECT_EQ(0, rawBuf->headroom());
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicBatchWriterTest, QuicBatchWriterTest,
QuicBatchWriterTest, QuicBatchWriterTest,
::testing::Values(false, true)); ::testing::Values(false, true));

2
quic/api/test/QuicPacketSchedulerTest.cpp
View File

@ -2209,7 +2209,7 @@ TEST_F(QuicPacketSchedulerTest, ShortHeaderPaddingMaxPacketLength) {
EXPECT_EQ(packetLength, conn.udpSendPacketLen); EXPECT_EQ(packetLength, conn.udpSendPacketLen);
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicPacketSchedulerTests, QuicPacketSchedulerTests,
QuicPacketSchedulerTest, QuicPacketSchedulerTest,
Values(PacketBuilderType::Regular, PacketBuilderType::Inplace)); Values(PacketBuilderType::Regular, PacketBuilderType::Inplace));

4
quic/api/test/QuicTransportBaseTest.cpp
View File

@ -542,7 +542,7 @@ class QuicTransportImplTest : public Test {
class QuicTransportImplTestClose : public QuicTransportImplTest, class QuicTransportImplTestClose : public QuicTransportImplTest,
public testing::WithParamInterface<bool> {}; public testing::WithParamInterface<bool> {};
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicTransportImplTest, QuicTransportImplTest,
QuicTransportImplTestClose, QuicTransportImplTestClose,
Values(true, false)); Values(true, false));
@ -2858,7 +2858,7 @@ quic::StreamId createStream(
} }
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicTransportImplTest, QuicTransportImplTest,
QuicTransportImplTestUniBidi, QuicTransportImplTestUniBidi,
Values(true, false)); Values(true, false));

1
quic/client/QuicClientAsyncTransport.h
View File

@ -35,6 +35,7 @@ class QuicClientAsyncTransport : public QuicStreamAsyncTransport,
void onNewBidirectionalStream(StreamId id) noexcept override; void onNewBidirectionalStream(StreamId id) noexcept override;
void onNewUnidirectionalStream(StreamId id) noexcept override; void onNewUnidirectionalStream(StreamId id) noexcept override;
void onStopSending(StreamId id, ApplicationErrorCode error) noexcept override; void onStopSending(StreamId id, ApplicationErrorCode error) noexcept override;
using QuicSocket::ConnectionCallback::ConnectionCallback::onConnectionEnd;
void onConnectionEnd() noexcept override; void onConnectionEnd() noexcept override;
void onConnectionSetupError(QuicError code) noexcept override { void onConnectionSetupError(QuicError code) noexcept override {
onConnectionError(std::move(code)); onConnectionError(std::move(code));

56
quic/client/test/Mocks.h
View File

@ -21,9 +21,10 @@ namespace test {
class MockClientHandshakeFactory : public ClientHandshakeFactory { class MockClientHandshakeFactory : public ClientHandshakeFactory {
public: public:
MOCK_METHOD1( MOCK_METHOD(
std::unique_ptr<ClientHandshake>,
_makeClientHandshake, _makeClientHandshake,
std::unique_ptr<ClientHandshake>(QuicClientConnectionState*)); (QuicClientConnectionState*));
std::unique_ptr<ClientHandshake> std::unique_ptr<ClientHandshake>
makeClientHandshake(QuicClientConnectionState* conn) && override { makeClientHandshake(QuicClientConnectionState* conn) && override {
@ -44,40 +45,43 @@ class MockClientHandshake : public ClientHandshake {
EncryptionLevel encryptionLevel) override { EncryptionLevel encryptionLevel) override {
doHandshakeImpl(data.get(), encryptionLevel); doHandshakeImpl(data.get(), encryptionLevel);
} }
MOCK_METHOD2(doHandshakeImpl, void(folly::IOBuf*, EncryptionLevel)); MOCK_METHOD(void, doHandshakeImpl, (folly::IOBuf*, EncryptionLevel));
MOCK_METHOD2( MOCK_METHOD(
bool,
verifyRetryIntegrityTag, verifyRetryIntegrityTag,
bool(const ConnectionId&, const RetryPacket&)); (const ConnectionId&, const RetryPacket&));
MOCK_METHOD1(removePsk, void(const folly::Optional<std::string>&)); MOCK_METHOD(void, removePsk, (const folly::Optional<std::string>&));
MOCK_CONST_METHOD0(getCryptoFactory, const CryptoFactory&()); MOCK_METHOD(const CryptoFactory&, getCryptoFactory, (), (const));
MOCK_CONST_METHOD0(isTLSResumed, bool()); MOCK_METHOD(bool, isTLSResumed, (), (const));
MOCK_METHOD0(getZeroRttRejected, folly::Optional<bool>()); MOCK_METHOD(folly::Optional<bool>, getZeroRttRejected, ());
MOCK_METHOD0( MOCK_METHOD(
folly::Optional<ServerTransportParameters>,
getServerTransportParams, getServerTransportParams,
folly::Optional<ServerTransportParameters>()); ());
MOCK_METHOD0(destroy, void()); MOCK_METHOD(void, destroy, ());
MOCK_METHOD1( MOCK_METHOD(
folly::Optional<CachedServerTransportParameters>,
connectImpl, connectImpl,
folly::Optional<CachedServerTransportParameters>( (folly::Optional<std::string>));
folly::Optional<std::string>)); MOCK_METHOD(EncryptionLevel, getReadRecordLayerEncryptionLevel, ());
MOCK_METHOD0(getReadRecordLayerEncryptionLevel, EncryptionLevel()); MOCK_METHOD(void, processSocketData, (folly::IOBufQueue & queue));
MOCK_METHOD1(processSocketData, void(folly::IOBufQueue& queue)); MOCK_METHOD(bool, matchEarlyParameters, ());
MOCK_METHOD0(matchEarlyParameters, bool()); MOCK_METHOD(
MOCK_METHOD2( (std::pair<std::unique_ptr<Aead>, std::unique_ptr<PacketNumberCipher>>),
buildCiphers, buildCiphers,
std::pair<std::unique_ptr<Aead>, std::unique_ptr<PacketNumberCipher>>( (ClientHandshake::CipherKind kind, folly::ByteRange secret));
ClientHandshake::CipherKind kind, MOCK_METHOD(
folly::ByteRange secret)); const folly::Optional<std::string>&,
MOCK_CONST_METHOD0(
getApplicationProtocol, getApplicationProtocol,
const folly::Optional<std::string>&()); (),
(const));
}; };
class MockQuicConnectorCallback : public quic::QuicConnector::Callback { class MockQuicConnectorCallback : public quic::QuicConnector::Callback {
public: public:
MOCK_METHOD1(onConnectError, void(QuicError)); MOCK_METHOD(void, onConnectError, (QuicError));
MOCK_METHOD0(onConnectSuccess, void()); MOCK_METHOD(void, onConnectSuccess, ());
}; };
class MockQuicClientTransport : public quic::QuicClientTransport { class MockQuicClientTransport : public quic::QuicClientTransport {

65
quic/codec/test/Mocks.h
View File

@ -17,21 +17,17 @@ namespace test {
class MockConnectionIdAlgo : public ConnectionIdAlgo { class MockConnectionIdAlgo : public ConnectionIdAlgo {
public: public:
GMOCK_METHOD1_(, noexcept, , canParseNonConst, bool(const ConnectionId& id)); MOCK_METHOD(bool, canParseNonConst, (const ConnectionId& id), (noexcept));
GMOCK_METHOD1_( MOCK_METHOD(
, (folly::Expected<ServerConnectionIdParams, QuicInternalException>),
noexcept,
,
parseConnectionId, parseConnectionId,
folly::Expected<ServerConnectionIdParams, QuicInternalException>( (const ConnectionId&),
const ConnectionId&)); (noexcept));
GMOCK_METHOD1_( MOCK_METHOD(
, (folly::Expected<ConnectionId, QuicInternalException>),
noexcept,
,
encodeConnectionId, encodeConnectionId,
folly::Expected<ConnectionId, QuicInternalException>( (const ServerConnectionIdParams&),
const ServerConnectionIdParams&)); (noexcept));
bool canParse(const ConnectionId& id) const noexcept override { bool canParse(const ConnectionId& id) const noexcept override {
return const_cast<MockConnectionIdAlgo&>(*this).canParseNonConst(id); return const_cast<MockConnectionIdAlgo&>(*this).canParseNonConst(id);
@ -48,29 +44,32 @@ class MockQuicPacketBuilder : public PacketBuilderInterface {
void insert(std::unique_ptr<folly::IOBuf> buf, size_t limit) override { void insert(std::unique_ptr<folly::IOBuf> buf, size_t limit) override {
_insert(buf, limit); _insert(buf, limit);
} }
MOCK_METHOD1(appendFrame, void(QuicWriteFrame)); MOCK_METHOD(void, appendFrame, (QuicWriteFrame));
MOCK_METHOD1(_insert, void(std::unique_ptr<folly::IOBuf>&)); MOCK_METHOD(void, _insert, (std::unique_ptr<folly::IOBuf>&));
MOCK_METHOD2(_insert, void(std::unique_ptr<folly::IOBuf>&, size_t)); MOCK_METHOD(void, _insert, (std::unique_ptr<folly::IOBuf>&, size_t));
MOCK_METHOD2(insert, void(const BufQueue&, size_t)); MOCK_METHOD(void, insert, (const BufQueue&, size_t));
MOCK_METHOD2(push, void(const uint8_t*, size_t)); MOCK_METHOD(void, push, (const uint8_t*, size_t));
MOCK_METHOD1(write, void(const QuicInteger&)); MOCK_METHOD(void, write, (const QuicInteger&));
GMOCK_METHOD0_(, const, , remainingSpaceInPkt, uint32_t()); MOCK_METHOD(uint32_t, remainingSpaceInPkt, (), (const));
GMOCK_METHOD0_(, const, , getPacketHeader, const PacketHeader&()); MOCK_METHOD(const PacketHeader&, getPacketHeader, (), (const));
MOCK_METHOD1(writeBEUint8, void(uint8_t)); MOCK_METHOD(void, writeBEUint8, (uint8_t));
MOCK_METHOD1(writeBEUint16, void(uint16_t)); MOCK_METHOD(void, writeBEUint16, (uint16_t));
MOCK_METHOD1(writeBEUint64, void(uint16_t)); MOCK_METHOD(void, writeBEUint64, (uint16_t));
MOCK_METHOD2(appendBytes, void(PacketNum, uint8_t)); MOCK_METHOD(void, appendBytes, (PacketNum, uint8_t));
MOCK_METHOD3(appendBytesWithAppender, void(BufAppender&, PacketNum, uint8_t)); MOCK_METHOD(
MOCK_METHOD3(appendBytesWithBufWriter, void(BufWriter&, PacketNum, uint8_t)); void,
GMOCK_METHOD1_(, noexcept, , accountForCipherOverhead, void(uint8_t)); appendBytesWithAppender,
GMOCK_METHOD0_(, noexcept, , canBuildPacketNonConst, bool()); (BufAppender&, PacketNum, uint8_t));
GMOCK_METHOD0_(, const, , getHeaderBytes, uint32_t()); MOCK_METHOD(void, appendBytesWithBufWriter, (BufWriter&, PacketNum, uint8_t));
GMOCK_METHOD0_(, const, , hasFramesPending, bool()); MOCK_METHOD(void, accountForCipherOverhead, (uint8_t), (noexcept));
MOCK_METHOD0(releaseOutputBufferMock, void()); MOCK_METHOD(bool, canBuildPacketNonConst, (), (noexcept));
MOCK_METHOD0(encodePacketHeader, void()); MOCK_METHOD(uint32_t, getHeaderBytes, (), (const));
MOCK_METHOD(bool, hasFramesPending, (), (const));
MOCK_METHOD(void, releaseOutputBufferMock, ());
MOCK_METHOD(void, encodePacketHeader, ());
void releaseOutputBuffer() && override { void releaseOutputBuffer() && override {
releaseOutputBufferMock(); releaseOutputBufferMock();

6
quic/codec/test/PacketNumberTest.cpp
View File

@ -63,7 +63,7 @@ TEST_P(Packet32DecodeTest, Decode) {
EXPECT_EQ(GetParam().expected, decoded) << std::hex << decoded; EXPECT_EQ(GetParam().expected, decoded) << std::hex << decoded;
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
Packet8DecodeTests, Packet8DecodeTests,
Packet8DecodeTest, Packet8DecodeTest,
Values( Values(
@ -72,7 +72,7 @@ INSTANTIATE_TEST_CASE_P(
(Packet8DecodeData){0xaa82ffff, 0x01, 0xaa830001}, (Packet8DecodeData){0xaa82ffff, 0x01, 0xaa830001},
(Packet8DecodeData){0xaa82fffe, 0x01, 0xaa830001})); (Packet8DecodeData){0xaa82fffe, 0x01, 0xaa830001}));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
Packet16DecodeTests, Packet16DecodeTests,
Packet16DecodeTest, Packet16DecodeTest,
Values( Values(
@ -90,7 +90,7 @@ INSTANTIATE_TEST_CASE_P(
(Packet16DecodeData){0xaa82f30e, 0x9b3, 0xaa8309b3}, (Packet16DecodeData){0xaa82f30e, 0x9b3, 0xaa8309b3},
(Packet16DecodeData){0xa82f30ea, 0x9b32, 0xa82f9b32})); (Packet16DecodeData){0xa82f30ea, 0x9b32, 0xa82f9b32}));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
Packet32DecodeTests, Packet32DecodeTests,
Packet32DecodeTest, Packet32DecodeTest,
Values( Values(

4
quic/codec/test/QuicIntegerTest.cpp
View File

@ -125,7 +125,7 @@ TEST_F(QuicIntegerEncodeTest, ForceWrongBytes) {
EXPECT_DEATH(encodeQuicInteger(15293, appendOp, 1), ""); EXPECT_DEATH(encodeQuicInteger(15293, appendOp, 1), "");
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicIntegerTests, QuicIntegerTests,
QuicIntegerDecodeTest, QuicIntegerDecodeTest,
Values( Values(
@ -138,7 +138,7 @@ INSTANTIATE_TEST_CASE_P(
(IntegerParams){37, "C000000000000025", false, 8}, (IntegerParams){37, "C000000000000025", false, 8},
(IntegerParams){37, "40", true})); (IntegerParams){37, "40", true}));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicIntegerEncodeTests, QuicIntegerEncodeTests,
QuicIntegerEncodeTest, QuicIntegerEncodeTest,
Values( Values(

2
quic/codec/test/QuicPacketBuilderTest.cpp
View File

@ -785,7 +785,7 @@ TEST_P(QuicPacketBuilderTest, TestCipherOverhead) {
kDefaultUDPSendPacketLen - cipherOverhead); kDefaultUDPSendPacketLen - cipherOverhead);
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicPacketBuilderTests, QuicPacketBuilderTests,
QuicPacketBuilderTest, QuicPacketBuilderTest,
Values(TestFlavor::Regular, TestFlavor::Inplace)); Values(TestFlavor::Regular, TestFlavor::Inplace));

2
quic/common/test/MonitoredObjectTest.cpp
View File

@ -17,7 +17,7 @@ using namespace ::testing;
class MockObserver { class MockObserver {
public: public:
MOCK_METHOD1(accessed, void(const string&)); MOCK_METHOD(void, accessed, (const string&));
}; };
TEST(MonitoredObjectTest, TestObserverCalled) { TEST(MonitoredObjectTest, TestObserverCalled) {

8
quic/common/test/TestUtils.h
View File

@ -329,9 +329,11 @@ class FizzCryptoTestFactory : public FizzCryptoFactory {
std::unique_ptr<PacketNumberCipher> makePacketNumberCipher( std::unique_ptr<PacketNumberCipher> makePacketNumberCipher(
fizz::CipherSuite) const override; fizz::CipherSuite) const override;
MOCK_CONST_METHOD1( MOCK_METHOD(
std::unique_ptr<PacketNumberCipher>,
_makePacketNumberCipher, _makePacketNumberCipher,
std::unique_ptr<PacketNumberCipher>(folly::ByteRange)); (folly::ByteRange),
(const));
std::unique_ptr<PacketNumberCipher> makePacketNumberCipher( std::unique_ptr<PacketNumberCipher> makePacketNumberCipher(
folly::ByteRange secret) const override; folly::ByteRange secret) const override;
@ -397,7 +399,7 @@ class FakeServerHandshake : public FizzServerHandshake {
void accept(std::shared_ptr<ServerTransportParametersExtension>) override {} void accept(std::shared_ptr<ServerTransportParametersExtension>) override {}
MOCK_METHOD1(writeNewSessionTicket, void(const AppToken&)); MOCK_METHOD(void, writeNewSessionTicket, (const AppToken&));
void doHandshake(std::unique_ptr<folly::IOBuf> data, EncryptionLevel) void doHandshake(std::unique_ptr<folly::IOBuf> data, EncryptionLevel)
override { override {

30
quic/congestion_control/test/Mocks.h
View File

@ -15,30 +15,30 @@ class MockMinRttSampler : public BbrCongestionController::MinRttSampler {
public: public:
~MockMinRttSampler() override = default; ~MockMinRttSampler() override = default;
MOCK_CONST_METHOD0(minRtt, std::chrono::microseconds()); MOCK_METHOD(std::chrono::microseconds, minRtt, (), (const));
MOCK_CONST_METHOD0(minRttExpired, bool()); MOCK_METHOD(bool, minRttExpired, (), (const));
GMOCK_METHOD2_( MOCK_METHOD(
, bool,
noexcept,
,
newRttSample, newRttSample,
bool(std::chrono::microseconds, TimePoint)); (std::chrono::microseconds, TimePoint),
GMOCK_METHOD1_(, noexcept, , timestampMinRtt, void(TimePoint)); (noexcept));
MOCK_METHOD(void, timestampMinRtt, (TimePoint), (noexcept));
}; };
class MockBandwidthSampler : public BbrCongestionController::BandwidthSampler { class MockBandwidthSampler : public BbrCongestionController::BandwidthSampler {
public: public:
~MockBandwidthSampler() override = default; ~MockBandwidthSampler() override = default;
MOCK_CONST_METHOD0(getBandwidth, Bandwidth()); MOCK_METHOD(Bandwidth, getBandwidth, (), (const));
MOCK_CONST_METHOD0(getLatestSample, Bandwidth()); MOCK_METHOD(Bandwidth, getLatestSample, (), (const));
MOCK_CONST_METHOD0(isAppLimited, bool()); MOCK_METHOD(bool, isAppLimited, (), (const));
MOCK_METHOD2( MOCK_METHOD(
void,
onPacketAcked, onPacketAcked,
void(const CongestionController::AckEvent&, uint64_t)); (const CongestionController::AckEvent&, uint64_t));
MOCK_METHOD0(onAppLimited, void()); MOCK_METHOD(void, onAppLimited, ());
GMOCK_METHOD1_(, noexcept, , setWindowLength, void(const uint64_t)); MOCK_METHOD(void, setWindowLength, (const uint64_t), (noexcept));
}; };
} // namespace test } // namespace test

7
quic/d6d/test/Mocks.h
View File

@ -18,10 +18,11 @@ class MockProbeSizeRaiser : public ProbeSizeRaiser {
public: public:
~MockProbeSizeRaiser() override {} ~MockProbeSizeRaiser() override {}
MOCK_METHOD1(onProbeLost, void(uint16_t lastProbeSize)); MOCK_METHOD(void, onProbeLost, (uint16_t lastProbeSize));
MOCK_METHOD1( MOCK_METHOD(
folly::Optional<uint16_t>,
raiseProbeSize, raiseProbeSize,
folly::Optional<uint16_t>(uint16_t lastProbeSize)); (uint16_t lastProbeSize));
}; };
} // namespace test } // namespace test

4
quic/dsr/frontend/test/Mocks.h
View File

@ -14,13 +14,13 @@ namespace quic::test {
class MockDSRPacketBuilder : public DSRPacketBuilderBase { class MockDSRPacketBuilder : public DSRPacketBuilderBase {
public: public:
GMOCK_METHOD0_(, noexcept, , remainingSpaceNonConst, size_t()); MOCK_METHOD(size_t, remainingSpaceNonConst, (), (noexcept));
size_t remainingSpace() const noexcept override { size_t remainingSpace() const noexcept override {
return const_cast<MockDSRPacketBuilder&>(*this).remainingSpaceNonConst(); return const_cast<MockDSRPacketBuilder&>(*this).remainingSpaceNonConst();
} }
MOCK_METHOD2(addSendInstruction, void(SendInstruction&&, uint32_t)); MOCK_METHOD(void, addSendInstruction, (SendInstruction&&, uint32_t));
}; };
} // namespace quic::test } // namespace quic::test

6
quic/dsr/test/Mocks.h
View File

@ -18,9 +18,9 @@ namespace quic::test {
class MockDSRPacketizationRequestSender : public DSRPacketizationRequestSender { class MockDSRPacketizationRequestSender : public DSRPacketizationRequestSender {
public: public:
MOCK_METHOD1(addSendInstruction, bool(const SendInstruction&)); MOCK_METHOD(bool, addSendInstruction, (const SendInstruction&));
MOCK_METHOD0(flush, bool()); MOCK_METHOD(bool, flush, ());
MOCK_METHOD0(release, void()); MOCK_METHOD(void, release, ());
}; };
} // namespace quic::test } // namespace quic::test

6
quic/fizz/client/handshake/test/MockQuicPskCache.h
View File

@ -17,8 +17,8 @@
namespace quic { namespace quic {
class MockQuicPskCache : public QuicPskCache { class MockQuicPskCache : public QuicPskCache {
public: public:
MOCK_METHOD1(getPsk, folly::Optional<QuicCachedPsk>(const std::string&)); MOCK_METHOD(folly::Optional<QuicCachedPsk>, getPsk, (const std::string&));
MOCK_METHOD2(putPsk, void(const std::string&, QuicCachedPsk)); MOCK_METHOD(void, putPsk, (const std::string&, QuicCachedPsk));
MOCK_METHOD1(removePsk, void(const std::string&)); MOCK_METHOD(void, removePsk, (const std::string&));
}; };
} // namespace quic } // namespace quic

35
quic/fizz/client/test/QuicClientTransportTest.cpp
View File

@ -901,7 +901,7 @@ TEST_P(QuicClientTransportIntegrationTest, D6DEnabledTest) {
eventbase_.loopForever(); eventbase_.loopForever();
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicClientTransportIntegrationTests, QuicClientTransportIntegrationTests,
QuicClientTransportIntegrationTest, QuicClientTransportIntegrationTest,
::testing::Values( ::testing::Values(
@ -1065,22 +1065,21 @@ TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
onTransportReadyMock(); onTransportReadyMock();
} }
GMOCK_METHOD1_(, noexcept, , onFlowControlUpdate, void(StreamId)); MOCK_METHOD(void, onFlowControlUpdate, (StreamId), (noexcept));
GMOCK_METHOD1_(, noexcept, , onNewBidirectionalStream, void(StreamId)); MOCK_METHOD(void, onNewBidirectionalStream, (StreamId), (noexcept));
GMOCK_METHOD1_(, noexcept, , onNewUnidirectionalStream, void(StreamId)); MOCK_METHOD(void, onNewUnidirectionalStream, (StreamId), (noexcept));
GMOCK_METHOD2_( MOCK_METHOD(
, void,
noexcept,
,
onStopSending, onStopSending,
void(StreamId, ApplicationErrorCode)); (StreamId, ApplicationErrorCode),
GMOCK_METHOD0_(, noexcept, , onTransportReadyMock, void()); (noexcept));
GMOCK_METHOD0_(, noexcept, , onReplaySafe, void()); MOCK_METHOD(void, onTransportReadyMock, (), (noexcept));
GMOCK_METHOD0_(, noexcept, , onConnectionEnd, void()); MOCK_METHOD(void, onReplaySafe, (), (noexcept));
MOCK_METHOD(void, onConnectionEnd, (), (noexcept));
void onConnectionSetupError(QuicError error) noexcept override { void onConnectionSetupError(QuicError error) noexcept override {
onConnectionError(std::move(error)); onConnectionError(std::move(error));
} }
GMOCK_METHOD1_(, noexcept, , onConnectionError, void(QuicError)); MOCK_METHOD(void, onConnectionError, (QuicError), (noexcept));
private: private:
std::shared_ptr<QuicSocket> socket_; std::shared_ptr<QuicSocket> socket_;
@ -1963,7 +1962,7 @@ class QuicClientTransportHappyEyeballsTest
SocketAddress serverAddrV6{"::1", 443}; SocketAddress serverAddrV6{"::1", 443};
}; };
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicClientTransportHappyEyeballsTests, QuicClientTransportHappyEyeballsTests,
QuicClientTransportHappyEyeballsTest, QuicClientTransportHappyEyeballsTest,
::testing::Values( ::testing::Values(
@ -2138,7 +2137,7 @@ class QuicClientTransportAfterStartTest
: public QuicClientTransportAfterStartTestBase, : public QuicClientTransportAfterStartTestBase,
public testing::WithParamInterface<uint8_t> {}; public testing::WithParamInterface<uint8_t> {};
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicClientZeroLenConnIds, QuicClientZeroLenConnIds,
QuicClientTransportAfterStartTest, QuicClientTransportAfterStartTest,
::Values(0, 8)); ::Values(0, 8));
@ -3010,7 +3009,7 @@ class QuicClientTransportAfterStartTestClose
: public QuicClientTransportAfterStartTestBase, : public QuicClientTransportAfterStartTestBase,
public testing::WithParamInterface<bool> {}; public testing::WithParamInterface<bool> {};
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicClientTransportAfterStartTestCloseWithError, QuicClientTransportAfterStartTestCloseWithError,
QuicClientTransportAfterStartTestClose, QuicClientTransportAfterStartTestClose,
Values(true, false)); Values(true, false));
@ -3216,7 +3215,7 @@ class QuicClientTransportAfterStartTestTimeout
: public QuicClientTransportAfterStartTestBase, : public QuicClientTransportAfterStartTestBase,
public testing::WithParamInterface<QuicVersion> {}; public testing::WithParamInterface<QuicVersion> {};
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicClientTransportAfterStartTestTimeouts, QuicClientTransportAfterStartTestTimeouts,
QuicClientTransportAfterStartTestTimeout, QuicClientTransportAfterStartTestTimeout,
Values(QuicVersion::MVFST, QuicVersion::QUIC_V1, QuicVersion::QUIC_DRAFT)); 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, QuicClientZeroLenConnIds,
QuicProcessDataTest, QuicProcessDataTest,
::Values(0, 8)); ::Values(0, 8));

2
quic/fizz/handshake/test/FizzPacketNumberCipherTest.cpp
View File

@ -89,7 +89,7 @@ TEST_P(LongPacketNumberCipherTest, TestEncryptDecrypt) {
GetParam().decryptedPacketNumberBytes); GetParam().decryptedPacketNumberBytes);
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
LongPacketNumberCipherTests, LongPacketNumberCipherTests,
LongPacketNumberCipherTest, LongPacketNumberCipherTest,
::testing::Values( ::testing::Values(

45
quic/handshake/test/Mocks.h
View File

@ -24,10 +24,10 @@ class MockPacketNumberCipher : public PacketNumberCipher {
public: public:
virtual ~MockPacketNumberCipher() = default; virtual ~MockPacketNumberCipher() = default;
MOCK_METHOD1(setKey, void(folly::ByteRange key)); MOCK_METHOD(void, setKey, (folly::ByteRange key));
MOCK_CONST_METHOD1(mask, HeaderProtectionMask(folly::ByteRange)); MOCK_METHOD(HeaderProtectionMask, mask, (folly::ByteRange), (const));
MOCK_CONST_METHOD0(keyLength, size_t()); MOCK_METHOD(size_t, keyLength, (), (const));
MOCK_CONST_METHOD0(getKey, const Buf&()); MOCK_METHOD(const Buf&, getKey, (), (const));
void setDefaultKey() { void setDefaultKey() {
packetProtectionKey_ = getProtectionKey(); packetProtectionKey_ = getProtectionKey();
@ -41,15 +41,16 @@ class MockPacketNumberCipher : public PacketNumberCipher {
class MockAead : public Aead { class MockAead : public Aead {
public: public:
MOCK_CONST_METHOD0(getCipherOverhead, size_t()); MOCK_METHOD(size_t, getCipherOverhead, (), (const));
MOCK_CONST_METHOD0(getKey, folly::Optional<TrafficKey>()); MOCK_METHOD(folly::Optional<TrafficKey>, getKey, (), (const));
MOCK_CONST_METHOD3( MOCK_METHOD(
std::unique_ptr<folly::IOBuf>,
_inplaceEncrypt, _inplaceEncrypt,
std::unique_ptr<folly::IOBuf>( (std::unique_ptr<folly::IOBuf> & plaintext,
std::unique_ptr<folly::IOBuf>& plaintext, const folly::IOBuf* associatedData,
const folly::IOBuf* associatedData, uint64_t seqNum),
uint64_t seqNum)); (const));
std::unique_ptr<folly::IOBuf> inplaceEncrypt( std::unique_ptr<folly::IOBuf> inplaceEncrypt(
std::unique_ptr<folly::IOBuf>&& plaintext, std::unique_ptr<folly::IOBuf>&& plaintext,
const folly::IOBuf* associatedData, const folly::IOBuf* associatedData,
@ -57,12 +58,13 @@ class MockAead : public Aead {
return _inplaceEncrypt(plaintext, associatedData, seqNum); return _inplaceEncrypt(plaintext, associatedData, seqNum);
} }
MOCK_CONST_METHOD3( MOCK_METHOD(
std::unique_ptr<folly::IOBuf>,
_decrypt, _decrypt,
std::unique_ptr<folly::IOBuf>( (std::unique_ptr<folly::IOBuf> & ciphertext,
std::unique_ptr<folly::IOBuf>& ciphertext, const folly::IOBuf* associatedData,
const folly::IOBuf* associatedData, uint64_t seqNum),
uint64_t seqNum)); (const));
std::unique_ptr<folly::IOBuf> decrypt( std::unique_ptr<folly::IOBuf> decrypt(
std::unique_ptr<folly::IOBuf>&& ciphertext, std::unique_ptr<folly::IOBuf>&& ciphertext,
const folly::IOBuf* associatedData, const folly::IOBuf* associatedData,
@ -70,12 +72,13 @@ class MockAead : public Aead {
return _decrypt(ciphertext, associatedData, seqNum); return _decrypt(ciphertext, associatedData, seqNum);
} }
MOCK_CONST_METHOD3( MOCK_METHOD(
folly::Optional<std::unique_ptr<folly::IOBuf>>,
_tryDecrypt, _tryDecrypt,
folly::Optional<std::unique_ptr<folly::IOBuf>>( (std::unique_ptr<folly::IOBuf> & ciphertext,
std::unique_ptr<folly::IOBuf>& ciphertext, const folly::IOBuf* associatedData,
const folly::IOBuf* associatedData, uint64_t seqNum),
uint64_t seqNum)); (const));
folly::Optional<std::unique_ptr<folly::IOBuf>> tryDecrypt( folly::Optional<std::unique_ptr<folly::IOBuf>> tryDecrypt(
std::unique_ptr<folly::IOBuf>&& ciphertext, std::unique_ptr<folly::IOBuf>&& ciphertext,
const folly::IOBuf* associatedData, const folly::IOBuf* associatedData,

85
quic/logging/test/Mocks.h
View File

@ -16,52 +16,57 @@ class MockQLogger : public QLogger {
MockQLogger() = delete; MockQLogger() = delete;
MockQLogger(VantagePoint vp) : QLogger(vp, kHTTP3ProtocolType) {} MockQLogger(VantagePoint vp) : QLogger(vp, kHTTP3ProtocolType) {}
~MockQLogger() override = default; ~MockQLogger() override = default;
MOCK_METHOD2(addPacket, void(const RegularQuicPacket&, uint64_t)); MOCK_METHOD(void, addPacket, (const RegularQuicPacket&, uint64_t));
MOCK_METHOD3( MOCK_METHOD(
void,
addPacket, addPacket,
void(const VersionNegotiationPacket&, uint64_t, bool)); (const VersionNegotiationPacket&, uint64_t, bool));
MOCK_METHOD3(addPacket, void(const RetryPacket&, uint64_t, bool)); MOCK_METHOD(void, addPacket, (const RetryPacket&, uint64_t, bool));
MOCK_METHOD2(addPacket, void(const RegularQuicWritePacket&, uint64_t)); MOCK_METHOD(void, addPacket, (const RegularQuicWritePacket&, uint64_t));
MOCK_METHOD4(addConnectionClose, void(std::string, std::string, bool, bool)); MOCK_METHOD(void, addConnectionClose, (std::string, std::string, bool, bool));
MOCK_METHOD1(addTransportSummary, void(const TransportSummaryArgs&)); MOCK_METHOD(void, addTransportSummary, (const TransportSummaryArgs&));
MOCK_METHOD5( MOCK_METHOD(
void,
addCongestionMetricUpdate, addCongestionMetricUpdate,
void(uint64_t, uint64_t, std::string, std::string, std::string)); (uint64_t, uint64_t, std::string, std::string, std::string));
MOCK_METHOD2( MOCK_METHOD(
void,
addPacingMetricUpdate, addPacingMetricUpdate,
void(uint64_t, std::chrono::microseconds)); (uint64_t, std::chrono::microseconds));
MOCK_METHOD3( MOCK_METHOD(
void,
addPacingObservation, addPacingObservation,
void(std::string, std::string, std::string)); (std::string, std::string, std::string));
MOCK_METHOD2(addAppIdleUpdate, void(std::string, bool)); MOCK_METHOD(void, addAppIdleUpdate, (std::string, bool));
MOCK_METHOD2(addPacketDrop, void(size_t, std::string)); MOCK_METHOD(void, addPacketDrop, (size_t, std::string));
MOCK_METHOD1(addDatagramReceived, void(uint64_t)); MOCK_METHOD(void, addDatagramReceived, (uint64_t));
MOCK_METHOD4(addLossAlarm, void(PacketNum, uint64_t, uint64_t, std::string)); MOCK_METHOD(void, addLossAlarm, (PacketNum, uint64_t, uint64_t, std::string));
MOCK_METHOD3(addPacketsLost, void(PacketNum, uint64_t, uint64_t)); MOCK_METHOD(void, addPacketsLost, (PacketNum, uint64_t, uint64_t));
MOCK_METHOD1(addTransportStateUpdate, void(std::string)); MOCK_METHOD(void, addTransportStateUpdate, (std::string));
MOCK_METHOD2(addPacketBuffered, void(ProtectionType, uint64_t)); MOCK_METHOD(void, addPacketBuffered, (ProtectionType, uint64_t));
MOCK_METHOD4( MOCK_METHOD(
void,
addMetricUpdate, addMetricUpdate,
void( (std::chrono::microseconds,
std::chrono::microseconds, std::chrono::microseconds,
std::chrono::microseconds, std::chrono::microseconds,
std::chrono::microseconds, std::chrono::microseconds));
std::chrono::microseconds)); MOCK_METHOD(
MOCK_METHOD3( void,
addStreamStateUpdate, addStreamStateUpdate,
void( (quic::StreamId,
quic::StreamId, std::string,
std::string, folly::Optional<std::chrono::milliseconds>));
folly::Optional<std::chrono::milliseconds>)); MOCK_METHOD(
MOCK_METHOD2( void,
addBandwidthEstUpdate, addBandwidthEstUpdate,
void(uint64_t, std::chrono::microseconds)); (uint64_t, std::chrono::microseconds));
MOCK_METHOD0(addAppLimitedUpdate, void()); MOCK_METHOD(void, addAppLimitedUpdate, ());
MOCK_METHOD0(addAppUnlimitedUpdate, void()); MOCK_METHOD(void, addAppUnlimitedUpdate, ());
MOCK_METHOD1(addConnectionMigrationUpdate, void(bool)); MOCK_METHOD(void, addConnectionMigrationUpdate, (bool));
MOCK_METHOD1(addPathValidationEvent, void(bool)); MOCK_METHOD(void, addPathValidationEvent, (bool));
MOCK_METHOD1(setDcid, void(folly::Optional<ConnectionId>)); MOCK_METHOD(void, setDcid, (folly::Optional<ConnectionId>));
MOCK_METHOD1(setScid, void(folly::Optional<ConnectionId>)); MOCK_METHOD(void, setScid, (folly::Optional<ConnectionId>));
MOCK_METHOD3(addPriorityUpdate, void(quic::StreamId, uint8_t, bool)); MOCK_METHOD(void, addPriorityUpdate, (quic::StreamId, uint8_t, bool));
}; };
} // namespace quic::test } // namespace quic::test

8
quic/loss/test/QuicLossFunctionsTest.cpp
View File

@ -63,9 +63,9 @@ namespace test {
class MockLossTimeout { class MockLossTimeout {
public: public:
MOCK_METHOD0(cancelLossTimeout, void()); MOCK_METHOD(void, cancelLossTimeout, ());
MOCK_METHOD1(scheduleLossTimeout, void(std::chrono::milliseconds)); MOCK_METHOD(void, scheduleLossTimeout, (std::chrono::milliseconds));
MOCK_METHOD0(isLossTimeoutScheduled, bool()); MOCK_METHOD(bool, isLossTimeoutScheduled, ());
}; };
enum class PacketType { enum class PacketType {
@ -2547,7 +2547,7 @@ TEST_F(QuicLossFunctionsTest, LossVisitorDSRTest) {
EXPECT_FALSE(conn->streamManager->writableDSRStreams().empty()); EXPECT_FALSE(conn->streamManager->writableDSRStreams().empty());
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicLossFunctionsTests, QuicLossFunctionsTests,
QuicLossFunctionsTest, QuicLossFunctionsTest,
Values( Values(

2
quic/server/handshake/test/ServerHandshakeTest.cpp
View File

@ -47,7 +47,7 @@ class MockServerHandshakeCallback : public ServerHandshake::HandshakeCallback {
public: public:
~MockServerHandshakeCallback() override = default; ~MockServerHandshakeCallback() override = default;
GMOCK_METHOD0_(, noexcept, , onCryptoEventAvailable, void()); MOCK_METHOD(void, onCryptoEventAvailable, (), (noexcept));
}; };
struct TestingServerConnectionState : public QuicServerConnectionState { struct TestingServerConnectionState : public QuicServerConnectionState {

83
quic/server/test/Mocks.h
View File

@ -18,20 +18,11 @@ namespace quic {
class MockServerConnectionIdRejector : public ServerConnectionIdRejector { class MockServerConnectionIdRejector : public ServerConnectionIdRejector {
public: public:
#if defined(MOCK_METHOD)
MOCK_METHOD( MOCK_METHOD(
(bool), (bool),
rejectConnectionIdNonConst, rejectConnectionIdNonConst,
(const ConnectionId), (const ConnectionId),
(noexcept)); (noexcept));
#else
GMOCK_METHOD1_(
,
noexcept,
,
rejectConnectionIdNonConst,
bool(const ConnectionId));
#endif
bool rejectConnectionId(const ConnectionId& id) const noexcept override { bool rejectConnectionId(const ConnectionId& id) const noexcept override {
return const_cast<MockServerConnectionIdRejector&>(*this) return const_cast<MockServerConnectionIdRejector&>(*this)
@ -54,7 +45,6 @@ class MockQuicServerTransportFactory : public QuicServerTransportFactory {
return _make(evb, socket, addr, ctx); return _make(evb, socket, addr, ctx);
} }
#if defined(MOCK_METHOD)
MOCK_METHOD( MOCK_METHOD(
(QuicServerTransport::Ptr), (QuicServerTransport::Ptr),
_make, _make,
@ -63,42 +53,30 @@ class MockQuicServerTransportFactory : public QuicServerTransportFactory {
const folly::SocketAddress&, const folly::SocketAddress&,
std::shared_ptr<const fizz::server::FizzServerContext>), std::shared_ptr<const fizz::server::FizzServerContext>),
(noexcept)); (noexcept));
#else
GMOCK_METHOD4_(
,
noexcept,
,
_make,
QuicServerTransport::Ptr(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket>& sock,
const folly::SocketAddress&,
std::shared_ptr<const fizz::server::FizzServerContext>));
#endif
}; };
class MockWorkerCallback : public QuicServerWorker::WorkerCallback { class MockWorkerCallback : public QuicServerWorker::WorkerCallback {
public: public:
~MockWorkerCallback() = default; ~MockWorkerCallback() = default;
MOCK_METHOD1(handleWorkerError, void(LocalErrorCode)); MOCK_METHOD(void, handleWorkerError, (LocalErrorCode));
MOCK_METHOD5( MOCK_METHOD(
void,
routeDataToWorkerLong, routeDataToWorkerLong,
void( (const folly::SocketAddress&,
const folly::SocketAddress&, std::unique_ptr<RoutingData>&,
std::unique_ptr<RoutingData>&, std::unique_ptr<NetworkData>&,
std::unique_ptr<NetworkData>&, folly::Optional<QuicVersion>,
folly::Optional<QuicVersion>, bool isForwardedData));
bool isForwardedData));
MOCK_METHOD5( MOCK_METHOD(
void,
routeDataToWorkerShort, routeDataToWorkerShort,
void( (const folly::SocketAddress&,
const folly::SocketAddress&, std::unique_ptr<RoutingData>&,
std::unique_ptr<RoutingData>&, std::unique_ptr<NetworkData>&,
std::unique_ptr<NetworkData>&, folly::Optional<QuicVersion>,
folly::Optional<QuicVersion>, bool isForwardedData));
bool isForwardedData));
void routeDataToWorker( void routeDataToWorker(
const folly::SocketAddress& client, const folly::SocketAddress& client,
@ -124,14 +102,13 @@ class MockQuicUDPSocketFactory : public QuicUDPSocketFactory {
std::unique_ptr<folly::AsyncUDPSocket> make(folly::EventBase* evb, int fd) { std::unique_ptr<folly::AsyncUDPSocket> make(folly::EventBase* evb, int fd) {
return std::unique_ptr<folly::AsyncUDPSocket>(_make(evb, fd)); return std::unique_ptr<folly::AsyncUDPSocket>(_make(evb, fd));
} }
MOCK_METHOD2(_make, folly::AsyncUDPSocket*(folly::EventBase*, int)); MOCK_METHOD(folly::AsyncUDPSocket*, _make, (folly::EventBase*, int));
}; };
class MockRoutingCallback : public QuicServerTransport::RoutingCallback { class MockRoutingCallback : public QuicServerTransport::RoutingCallback {
public: public:
~MockRoutingCallback() override = default; ~MockRoutingCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD( MOCK_METHOD(
(void), (void),
onConnectionIdAvailable, onConnectionIdAvailable,
@ -149,29 +126,6 @@ class MockRoutingCallback : public QuicServerTransport::RoutingCallback {
const QuicServerTransport::SourceIdentity&, const QuicServerTransport::SourceIdentity&,
const std::vector<ConnectionIdData>&), const std::vector<ConnectionIdData>&),
(noexcept)); (noexcept));
#else
GMOCK_METHOD2_(
,
noexcept,
,
onConnectionIdAvailable,
void(QuicServerTransport::Ptr, ConnectionId));
GMOCK_METHOD1_(
,
noexcept,
,
onConnectionIdBound,
void(QuicServerTransport::Ptr));
GMOCK_METHOD3_(
,
noexcept,
,
onConnectionUnbound,
void(
QuicServerTransport*,
const QuicServerTransport::SourceIdentity&,
const std::vector<ConnectionIdData>& connIdData));
#endif
}; };
class MockHandshakeFinishedCallback class MockHandshakeFinishedCallback
@ -179,13 +133,8 @@ class MockHandshakeFinishedCallback
public: public:
~MockHandshakeFinishedCallback() override = default; ~MockHandshakeFinishedCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onHandshakeFinished, (), (noexcept)); MOCK_METHOD((void), onHandshakeFinished, (), (noexcept));
MOCK_METHOD((void), onHandshakeUnfinished, (), (noexcept)); MOCK_METHOD((void), onHandshakeUnfinished, (), (noexcept));
#else
GMOCK_METHOD0_(, noexcept, , onHandshakeFinished, void());
GMOCK_METHOD0_(, noexcept, , onHandshakeUnfinished, void());
#endif
}; };
class MockQuicServerTransport : public QuicServerTransport { class MockQuicServerTransport : public QuicServerTransport {

8
quic/server/test/QuicServerTest.cpp
View File

@ -1413,10 +1413,10 @@ TEST_F(QuicServerWorkerTest, AssignBufAccessor) {
class MockAcceptObserver : public AcceptObserver { class MockAcceptObserver : public AcceptObserver {
public: public:
GMOCK_METHOD1_(, noexcept, , accept, void(QuicTransportBase* const)); MOCK_METHOD(void, accept, (QuicTransportBase* const), (noexcept));
GMOCK_METHOD1_(, noexcept, , acceptorDestroy, void(QuicServerWorker*)); MOCK_METHOD(void, acceptorDestroy, (QuicServerWorker*), (noexcept));
GMOCK_METHOD1_(, noexcept, , observerAttach, void(QuicServerWorker*)); MOCK_METHOD(void, observerAttach, (QuicServerWorker*), (noexcept));
GMOCK_METHOD1_(, noexcept, , observerDetach, void(QuicServerWorker*)); MOCK_METHOD(void, observerDetach, (QuicServerWorker*), (noexcept));
}; };
TEST_F(QuicServerWorkerTest, AcceptObserver) { TEST_F(QuicServerWorkerTest, AcceptObserver) {

6
quic/server/test/QuicServerTransportTest.cpp
View File

@ -1734,7 +1734,7 @@ class QuicServerTransportAllowMigrationTest
} }
}; };
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicServerTransportMigrationTests, QuicServerTransportMigrationTests,
QuicServerTransportAllowMigrationTest, QuicServerTransportAllowMigrationTest,
Values( Values(
@ -3683,7 +3683,7 @@ class QuicServerTransportPendingDataTest
} }
}; };
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicServerTransportPendingDataTests, QuicServerTransportPendingDataTests,
QuicServerTransportPendingDataTest, QuicServerTransportPendingDataTest,
Values( Values(
@ -3942,7 +3942,7 @@ class QuicServerTransportHandshakeTest
std::vector<folly::IPAddress> expectedSourceToken_; std::vector<folly::IPAddress> expectedSourceToken_;
}; };
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicServerTransportHandshakeTests, QuicServerTransportHandshakeTests,
QuicServerTransportHandshakeTest, QuicServerTransportHandshakeTest,
Values( Values(

2
quic/state/test/AckHandlersTest.cpp
View File

@ -5235,7 +5235,7 @@ TEST_F(AckEventForAppDataTest, AckEventRetransMultipleDupack) {
} }
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
AckHandlersTests, AckHandlersTests,
AckHandlersTest, AckHandlersTest,
Values( Values(

106
quic/state/test/MockQuicStats.h
View File

@ -17,64 +17,64 @@ namespace quic {
class MockQuicStats : public QuicTransportStatsCallback { class MockQuicStats : public QuicTransportStatsCallback {
public: public:
MOCK_METHOD0(onPacketReceived, void()); MOCK_METHOD(void, onPacketReceived, ());
MOCK_METHOD0(onDuplicatedPacketReceived, void()); MOCK_METHOD(void, onDuplicatedPacketReceived, ());
MOCK_METHOD0(onOutOfOrderPacketReceived, void()); MOCK_METHOD(void, onOutOfOrderPacketReceived, ());
MOCK_METHOD0(onPacketProcessed, void()); MOCK_METHOD(void, onPacketProcessed, ());
MOCK_METHOD0(onPacketSent, void()); MOCK_METHOD(void, onPacketSent, ());
MOCK_METHOD0(onPacketRetransmission, void()); MOCK_METHOD(void, onPacketRetransmission, ());
MOCK_METHOD0(onPacketLoss, void()); MOCK_METHOD(void, onPacketLoss, ());
MOCK_METHOD0(onPacketSpuriousLoss, void()); MOCK_METHOD(void, onPacketSpuriousLoss, ());
MOCK_METHOD0(onPersistentCongestion, void()); MOCK_METHOD(void, onPersistentCongestion, ());
MOCK_METHOD1(onPacketDropped, void(PacketDropReason)); MOCK_METHOD(void, onPacketDropped, (PacketDropReason));
MOCK_METHOD0(onPacketForwarded, void()); MOCK_METHOD(void, onPacketForwarded, ());
MOCK_METHOD0(onForwardedPacketReceived, void()); MOCK_METHOD(void, onForwardedPacketReceived, ());
MOCK_METHOD0(onForwardedPacketProcessed, void()); MOCK_METHOD(void, onForwardedPacketProcessed, ());
MOCK_METHOD1(onClientInitialReceived, void(QuicVersion)); MOCK_METHOD(void, onClientInitialReceived, (QuicVersion));
MOCK_METHOD0(onConnectionRateLimited, void()); MOCK_METHOD(void, onConnectionRateLimited, ());
MOCK_METHOD0(onNewConnection, void()); MOCK_METHOD(void, onNewConnection, ());
MOCK_METHOD1(onConnectionClose, void(folly::Optional<QuicErrorCode>)); MOCK_METHOD(void, onConnectionClose, (folly::Optional<QuicErrorCode>));
MOCK_METHOD0(onConnectionCloseZeroBytesWritten, void()); MOCK_METHOD(void, onConnectionCloseZeroBytesWritten, ());
MOCK_METHOD0(onNewQuicStream, void()); MOCK_METHOD(void, onNewQuicStream, ());
MOCK_METHOD0(onQuicStreamClosed, void()); MOCK_METHOD(void, onQuicStreamClosed, ());
MOCK_METHOD1(onQuicStreamReset, void(QuicErrorCode)); MOCK_METHOD(void, onQuicStreamReset, (QuicErrorCode));
MOCK_METHOD0(onConnFlowControlUpdate, void()); MOCK_METHOD(void, onConnFlowControlUpdate, ());
MOCK_METHOD0(onConnFlowControlBlocked, void()); MOCK_METHOD(void, onConnFlowControlBlocked, ());
MOCK_METHOD0(onStatelessReset, void()); MOCK_METHOD(void, onStatelessReset, ());
MOCK_METHOD0(onStreamFlowControlUpdate, void()); MOCK_METHOD(void, onStreamFlowControlUpdate, ());
MOCK_METHOD0(onStreamFlowControlBlocked, void()); MOCK_METHOD(void, onStreamFlowControlBlocked, ());
MOCK_METHOD0(onCwndBlocked, void()); MOCK_METHOD(void, onCwndBlocked, ());
MOCK_METHOD1(onNewCongestionController, void(CongestionControlType)); MOCK_METHOD(void, onNewCongestionController, (CongestionControlType));
MOCK_METHOD0(onPTO, void()); MOCK_METHOD(void, onPTO, ());
MOCK_METHOD1(onRead, void(size_t)); MOCK_METHOD(void, onRead, (size_t));
MOCK_METHOD1(onWrite, void(size_t)); MOCK_METHOD(void, onWrite, (size_t));
MOCK_METHOD1(onUDPSocketWriteError, void(SocketErrorType)); MOCK_METHOD(void, onUDPSocketWriteError, (SocketErrorType));
MOCK_METHOD0(onConnectionD6DStarted, void()); MOCK_METHOD(void, onConnectionD6DStarted, ());
MOCK_METHOD0(onConnectionPMTURaised, void()); MOCK_METHOD(void, onConnectionPMTURaised, ());
MOCK_METHOD0(onConnectionPMTUBlackholeDetected, void()); MOCK_METHOD(void, onConnectionPMTUBlackholeDetected, ());
MOCK_METHOD0(onConnectionPMTUUpperBoundDetected, void()); MOCK_METHOD(void, onConnectionPMTUUpperBoundDetected, ());
MOCK_METHOD1(onTransportKnobApplied, void(TransportKnobParamId)); MOCK_METHOD(void, onTransportKnobApplied, (TransportKnobParamId));
MOCK_METHOD1(onTransportKnobError, void(TransportKnobParamId)); MOCK_METHOD(void, onTransportKnobError, (TransportKnobParamId));
MOCK_METHOD0(onServerUnfinishedHandshake, void()); MOCK_METHOD(void, onServerUnfinishedHandshake, ());
MOCK_METHOD0(onZeroRttBuffered, void()); MOCK_METHOD(void, onZeroRttBuffered, ());
MOCK_METHOD0(onZeroRttBufferedPruned, void()); MOCK_METHOD(void, onZeroRttBufferedPruned, ());
MOCK_METHOD0(onZeroRttAccepted, void()); MOCK_METHOD(void, onZeroRttAccepted, ());
MOCK_METHOD0(onZeroRttRejected, void()); MOCK_METHOD(void, onZeroRttRejected, ());
MOCK_METHOD1(onDatagramRead, void(size_t)); MOCK_METHOD(void, onDatagramRead, (size_t));
MOCK_METHOD1(onDatagramWrite, void(size_t)); MOCK_METHOD(void, onDatagramWrite, (size_t));
MOCK_METHOD0(onDatagramDroppedOnWrite, void()); MOCK_METHOD(void, onDatagramDroppedOnWrite, ());
MOCK_METHOD0(onDatagramDroppedOnRead, void()); MOCK_METHOD(void, onDatagramDroppedOnRead, ());
MOCK_METHOD0(onNewTokenReceived, void()); MOCK_METHOD(void, onNewTokenReceived, ());
MOCK_METHOD0(onNewTokenIssued, void()); MOCK_METHOD(void, onNewTokenIssued, ());
MOCK_METHOD0(onTokenDecryptFailure, void()); MOCK_METHOD(void, onTokenDecryptFailure, ());
MOCK_METHOD1(onShortHeaderPadding, void(size_t)); MOCK_METHOD(void, onShortHeaderPadding, (size_t));
MOCK_METHOD0(onPacerTimerLagged, void()); MOCK_METHOD(void, onPacerTimerLagged, ());
}; };
class MockQuicStatsFactory : public QuicTransportStatsCallbackFactory { class MockQuicStatsFactory : public QuicTransportStatsCallbackFactory {
public: public:
~MockQuicStatsFactory() override = default; ~MockQuicStatsFactory() override = default;
MOCK_METHOD0(make, std::unique_ptr<QuicTransportStatsCallback>()); MOCK_METHOD(std::unique_ptr<QuicTransportStatsCallback>, make, ());
}; };
} // namespace quic } // namespace quic

75
quic/state/test/Mocks.h
View File

@ -16,59 +16,62 @@ namespace test {
class MockCongestionController : public CongestionController { class MockCongestionController : public CongestionController {
public: public:
~MockCongestionController() override {} ~MockCongestionController() override {}
MOCK_METHOD1(onRemoveBytesFromInflight, void(uint64_t)); MOCK_METHOD(void, onRemoveBytesFromInflight, (uint64_t));
MOCK_METHOD1(onPacketSent, void(const OutstandingPacket&)); MOCK_METHOD(void, onPacketSent, (const OutstandingPacket&));
MOCK_METHOD2( MOCK_METHOD(
void,
onPacketAckOrLoss, onPacketAckOrLoss,
void(const AckEvent* FOLLY_NULLABLE, const LossEvent* FOLLY_NULLABLE)); (const AckEvent* FOLLY_NULLABLE, const LossEvent* FOLLY_NULLABLE));
MOCK_CONST_METHOD0(getWritableBytes, uint64_t()); MOCK_METHOD(uint64_t, getWritableBytes, (), (const));
MOCK_CONST_METHOD0(getCongestionWindow, uint64_t()); MOCK_METHOD(uint64_t, getCongestionWindow, (), (const));
MOCK_METHOD0(onSpuriousLoss, void()); MOCK_METHOD(void, onSpuriousLoss, ());
MOCK_CONST_METHOD0(type, CongestionControlType()); MOCK_METHOD(CongestionControlType, type, (), (const));
GMOCK_METHOD2_(, , , setAppIdle, void(bool, TimePoint)); MOCK_METHOD(void, setAppIdle, (bool, TimePoint));
MOCK_METHOD0(setAppLimited, void()); MOCK_METHOD(void, setAppLimited, ());
GMOCK_METHOD1_(, noexcept, , setBandwidthUtilizationFactor, void(float)); MOCK_METHOD(void, setBandwidthUtilizationFactor, (float), (noexcept));
MOCK_CONST_METHOD0(isInBackgroundMode, bool()); MOCK_METHOD(bool, isInBackgroundMode, (), (const));
MOCK_CONST_METHOD0(isAppLimited, bool()); MOCK_METHOD(bool, isAppLimited, (), (const));
MOCK_CONST_METHOD1(getStats, void(CongestionControllerStats&)); MOCK_METHOD(void, getStats, (CongestionControllerStats&), (const));
MOCK_METHOD1(setExperimental, void(bool)); MOCK_METHOD(void, setExperimental, (bool));
}; };
class MockPacer : public Pacer { class MockPacer : public Pacer {
public: public:
MOCK_METHOD3( MOCK_METHOD(
void,
refreshPacingRate, refreshPacingRate,
void(uint64_t, std::chrono::microseconds, TimePoint currentTime)); (uint64_t, std::chrono::microseconds, TimePoint currentTime));
MOCK_METHOD1(setPacingRate, void(uint64_t)); MOCK_METHOD(void, setPacingRate, (uint64_t));
MOCK_METHOD1(setMaxPacingRate, void(uint64_t)); MOCK_METHOD(void, setMaxPacingRate, (uint64_t));
MOCK_METHOD0(reset, void()); MOCK_METHOD(void, reset, ());
MOCK_METHOD2(setRttFactor, void(uint8_t, uint8_t)); MOCK_METHOD(void, setRttFactor, (uint8_t, uint8_t));
MOCK_CONST_METHOD1( MOCK_METHOD(
std::chrono::microseconds,
getTimeUntilNextWrite, getTimeUntilNextWrite,
std::chrono::microseconds(TimePoint)); (TimePoint),
MOCK_METHOD1(updateAndGetWriteBatchSize, uint64_t(TimePoint)); (const));
MOCK_CONST_METHOD0(getCachedWriteBatchSize, uint64_t()); MOCK_METHOD(uint64_t, updateAndGetWriteBatchSize, (TimePoint));
MOCK_METHOD1(setAppLimited, void(bool)); MOCK_METHOD(uint64_t, getCachedWriteBatchSize, (), (const));
MOCK_METHOD0(onPacketSent, void()); MOCK_METHOD(void, setAppLimited, (bool));
MOCK_METHOD0(onPacketsLoss, void()); MOCK_METHOD(void, onPacketSent, ());
MOCK_METHOD1(setExperimental, void(bool)); MOCK_METHOD(void, onPacketsLoss, ());
MOCK_METHOD(void, setExperimental, (bool));
}; };
class MockPendingPathRateLimiter : public PendingPathRateLimiter { class MockPendingPathRateLimiter : public PendingPathRateLimiter {
public: public:
MockPendingPathRateLimiter() : PendingPathRateLimiter(0) {} MockPendingPathRateLimiter() : PendingPathRateLimiter(0) {}
MOCK_METHOD1(onPacketSent, void(uint64_t)); MOCK_METHOD(void, onPacketSent, (uint64_t));
GMOCK_METHOD2_( MOCK_METHOD(
, uint64_t,
noexcept,
,
currentCredit, currentCredit,
uint64_t(TimePoint, std::chrono::microseconds)); (TimePoint, std::chrono::microseconds),
(noexcept));
}; };
class MockQuicStreamPrioritiesObserver : public QuicStreamPrioritiesObserver { class MockQuicStreamPrioritiesObserver : public QuicStreamPrioritiesObserver {
public: public:
MOCK_METHOD0(onStreamPrioritiesChange, void()); MOCK_METHOD(void, onStreamPrioritiesChange, ());
}; };
} // namespace test } // namespace test
} // namespace quic } // namespace quic

6
quic/state/test/QuicStateFunctionsTest.cpp
View File

@ -82,7 +82,7 @@ TEST_P(UpdateLargestReceivedPacketNumTest, ReceiveOld) {
currentLargestReceived); currentLargestReceived);
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
UpdateLargestReceivedPacketNumTests, UpdateLargestReceivedPacketNumTests,
UpdateLargestReceivedPacketNumTest, UpdateLargestReceivedPacketNumTest,
Values( Values(
@ -506,7 +506,7 @@ TEST_P(
EXPECT_FALSE(verifyToScheduleAckTimeout(conn)); EXPECT_FALSE(verifyToScheduleAckTimeout(conn));
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
UpdateAckStateTests, UpdateAckStateTests,
UpdateAckStateTest, UpdateAckStateTest,
Values( Values(
@ -874,7 +874,7 @@ TEST_P(QuicStateFunctionsTest, CloseTranportStateChange) {
EXPECT_TRUE(conn.pendingEvents.closeTransport); EXPECT_TRUE(conn.pendingEvents.closeTransport);
} }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_SUITE_P(
QuicStateFunctionsTests, QuicStateFunctionsTests,
QuicStateFunctionsTest, QuicStateFunctionsTest,
Values( Values(