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
[dependencies.all(test=on, not(os=windows))]
googletest_1_8
googletest
[shipit.pathmap]
fbcode/quic/public_root = .

2
build/fbcode_builder/manifests/proxygen
View File

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

2
build_helper.sh
View File

@ -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

4
cmake/QuicTest.cmake
View File

@ -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)

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

@ -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<QuicError>));
MOCK_METHOD0(closeGracefully, void());
MOCK_METHOD1(closeNow, void(folly::Optional<QuicError>));
MOCK_CONST_METHOD0(
MOCK_METHOD(bool, good, (), (const));
MOCK_METHOD(bool, replaySafe, (), (const));
MOCK_METHOD(bool, error, (), (const));
MOCK_METHOD(void, close, (folly::Optional<QuicError>));
MOCK_METHOD(void, closeGracefully, ());
MOCK_METHOD(void, closeNow, (folly::Optional<QuicError>));
MOCK_METHOD(
folly::Optional<quic::ConnectionId>,
getClientConnectionId,
folly::Optional<quic::ConnectionId>());
MOCK_CONST_METHOD0(getTransportSettings, const TransportSettings&());
MOCK_CONST_METHOD0(
(),
(const));
MOCK_METHOD(const TransportSettings&, getTransportSettings, (), (const));
MOCK_METHOD(
folly::Optional<quic::ConnectionId>,
getServerConnectionId,
folly::Optional<quic::ConnectionId>());
MOCK_CONST_METHOD0(
(),
(const));
MOCK_METHOD(
folly::Optional<quic::ConnectionId>,
getClientChosenDestConnectionId,
folly::Optional<quic::ConnectionId>());
MOCK_CONST_METHOD0(getPeerAddress, const folly::SocketAddress&());
MOCK_CONST_METHOD0(getOriginalPeerAddress, const folly::SocketAddress&());
MOCK_CONST_METHOD0(getLocalAddress, const folly::SocketAddress&());
MOCK_CONST_METHOD0(getEventBase, folly::EventBase*());
MOCK_CONST_METHOD1(
(),
(const));
MOCK_METHOD(const folly::SocketAddress&, getPeerAddress, (), (const));
MOCK_METHOD(const folly::SocketAddress&, getOriginalPeerAddress, (), (const));
MOCK_METHOD(const folly::SocketAddress&, getLocalAddress, (), (const));
MOCK_METHOD(folly::EventBase*, getEventBase, (), (const));
MOCK_METHOD(
(folly::Expected<size_t, LocalErrorCode>),
getStreamReadOffset,
folly::Expected<size_t, LocalErrorCode>(StreamId));
MOCK_CONST_METHOD1(
(StreamId),
(const));
MOCK_METHOD(
(folly::Expected<size_t, LocalErrorCode>),
getStreamWriteOffset,
folly::Expected<size_t, LocalErrorCode>(StreamId));
MOCK_CONST_METHOD1(
(StreamId),
(const));
MOCK_METHOD(
(folly::Expected<size_t, LocalErrorCode>),
getStreamWriteBufferedBytes,
folly::Expected<size_t, LocalErrorCode>(StreamId));
MOCK_CONST_METHOD0(getTransportInfo, QuicSocket::TransportInfo());
MOCK_CONST_METHOD1(
(StreamId),
(const));
MOCK_METHOD(QuicSocket::TransportInfo, getTransportInfo, (), (const));
MOCK_METHOD(
(folly::Expected<QuicSocket::StreamTransportInfo, LocalErrorCode>),
getStreamTransportInfo,
folly::Expected<QuicSocket::StreamTransportInfo, LocalErrorCode>(
StreamId));
MOCK_CONST_METHOD0(getAppProtocol, folly::Optional<std::string>());
MOCK_METHOD2(setReceiveWindow, void(StreamId, size_t));
MOCK_METHOD3(setSendBuffer, void(StreamId, size_t, size_t));
MOCK_CONST_METHOD0(getConnectionBufferAvailable, uint64_t());
MOCK_CONST_METHOD0(
(StreamId),
(const));
MOCK_METHOD(folly::Optional<std::string>, getAppProtocol, (), (const));
MOCK_METHOD(void, setReceiveWindow, (StreamId, size_t));
MOCK_METHOD(void, setSendBuffer, (StreamId, size_t, size_t));
MOCK_METHOD(uint64_t, getConnectionBufferAvailable, (), (const));
MOCK_METHOD(
(folly::Expected<FlowControlState, LocalErrorCode>),
getConnectionFlowControl,
folly::Expected<FlowControlState, LocalErrorCode>());
MOCK_CONST_METHOD1(
(),
(const));
MOCK_METHOD(
(folly::Expected<FlowControlState, LocalErrorCode>),
getStreamFlowControl,
folly::Expected<FlowControlState, LocalErrorCode>(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<folly::Unit, LocalErrorCode>),
setConnectionFlowControlWindow,
folly::Expected<folly::Unit, LocalErrorCode>(uint64_t));
MOCK_METHOD2(
(uint64_t));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setStreamFlowControlWindow,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, uint64_t));
MOCK_METHOD1(setTransportSettings, void(TransportSettings));
MOCK_METHOD1(
(StreamId, uint64_t));
MOCK_METHOD(void, setTransportSettings, (TransportSettings));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setMaxPacingRate,
folly::Expected<folly::Unit, LocalErrorCode>(uint64_t));
(uint64_t));
folly::Expected<folly::Unit, LocalErrorCode>
setKnob(uint64_t knobSpace, uint64_t knobId, Buf knobBlob) override {
SharedBuf sharedBlob(knobBlob.release());
return setKnob(knobSpace, knobId, sharedBlob);
}
MOCK_METHOD3(
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setKnob,
folly::Expected<folly::Unit, LocalErrorCode>(
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<folly::Unit, LocalErrorCode>),
setStreamPriority,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, uint8_t, bool));
MOCK_METHOD1(
(StreamId, uint8_t, bool));
MOCK_METHOD(
(folly::Expected<Priority, LocalErrorCode>),
getStreamPriority,
folly::Expected<Priority, LocalErrorCode>(StreamId));
MOCK_METHOD3(
(StreamId));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setReadCallback,
folly::Expected<folly::Unit, LocalErrorCode>(
StreamId,
ReadCallback*,
folly::Optional<ApplicationErrorCode> err));
MOCK_METHOD1(setConnectionSetupCallback, void(ConnectionSetupCallback*));
MOCK_METHOD1(setConnectionCallback, void(ConnectionCallback*));
(StreamId, ReadCallback*, folly::Optional<ApplicationErrorCode> err));
MOCK_METHOD(void, setConnectionSetupCallback, (ConnectionSetupCallback*));
MOCK_METHOD(void, setConnectionCallback, (ConnectionCallback*));
void setEarlyDataAppParamsFunctions(
folly::Function<bool(const folly::Optional<std::string>&, 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<folly::Unit, LocalErrorCode>),
pauseRead,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
MOCK_METHOD1(
(StreamId));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
resumeRead,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
MOCK_METHOD2(
(StreamId));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
stopSending,
folly::Expected<folly::Unit, LocalErrorCode>(
StreamId,
ApplicationErrorCode));
(StreamId, ApplicationErrorCode));
folly::Expected<std::pair<Buf, bool>, LocalErrorCode> read(
StreamId id,
size_t maxRead) override {
@ -140,16 +160,17 @@ class MockQuicSocket : public QuicSocket {
}
using ReadResult =
folly::Expected<std::pair<folly::IOBuf*, bool>, LocalErrorCode>;
MOCK_METHOD2(readNaked, ReadResult(StreamId, size_t));
MOCK_METHOD1(
MOCK_METHOD(ReadResult, readNaked, (StreamId, size_t));
MOCK_METHOD(
(folly::Expected<StreamId, LocalErrorCode>),
createBidirectionalStream,
folly::Expected<StreamId, LocalErrorCode>(bool));
MOCK_METHOD1(
(bool));
MOCK_METHOD(
(folly::Expected<StreamId, LocalErrorCode>),
createUnidirectionalStream,
folly::Expected<StreamId, LocalErrorCode>(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<folly::Unit, LocalErrorCode>),
notifyPendingWriteOnConnection,
folly::Expected<folly::Unit, LocalErrorCode>(WriteCallback*));
MOCK_METHOD2(
(WriteCallback*));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
notifyPendingWriteOnStream,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, WriteCallback*));
MOCK_METHOD1(
(StreamId, WriteCallback*));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
unregisterStreamWriteCallback,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
MOCK_METHOD3(
(StreamId));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
registerTxCallback,
folly::Expected<folly::Unit, LocalErrorCode>(
const StreamId,
const uint64_t,
ByteEventCallback*));
MOCK_METHOD4(
(const StreamId, const uint64_t, ByteEventCallback*));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
registerByteEventCallback,
folly::Expected<folly::Unit, LocalErrorCode>(
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<uint64_t>& offset));
MOCK_METHOD3(
(const StreamId id, const folly::Optional<uint64_t>& offset));
MOCK_METHOD(
void,
cancelByteEventCallbacksForStream,
void(
const ByteEvent::Type,
const StreamId id,
const folly::Optional<uint64_t>& offset));
MOCK_METHOD0(cancelAllByteEventCallbacks, void());
MOCK_METHOD1(cancelByteEventCallbacks, void(const ByteEvent::Type));
MOCK_CONST_METHOD1(
(const ByteEvent::Type,
const StreamId id,
const folly::Optional<uint64_t>& offset));
MOCK_METHOD(void, cancelAllByteEventCallbacks, ());
MOCK_METHOD(void, cancelByteEventCallbacks, (const ByteEvent::Type));
MOCK_METHOD(
size_t,
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<folly::Unit, LocalErrorCode>
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<DSRPacketizationRequestSender>&));
(StreamId, const std::unique_ptr<DSRPacketizationRequestSender>&));
WriteResult setDSRPacketizationRequestSender(
StreamId streamId,
std::unique_ptr<DSRPacketizationRequestSender> sender) override {
return setDSRPacketizationRequestSenderRef(streamId, sender);
}
MOCK_METHOD3(
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
registerDeliveryCallback,
folly::Expected<folly::Unit, LocalErrorCode>(
StreamId,
uint64_t,
ByteEventCallback*));
(StreamId, uint64_t, ByteEventCallback*));
MOCK_METHOD1(shutdownWrite, folly::Optional<LocalErrorCode>(StreamId));
MOCK_METHOD2(
MOCK_METHOD(folly::Optional<LocalErrorCode>, shutdownWrite, (StreamId));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
resetStream,
folly::Expected<folly::Unit, LocalErrorCode>(
StreamId,
ApplicationErrorCode));
MOCK_METHOD2(
(StreamId, ApplicationErrorCode));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
maybeResetStreamFromReadError,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, QuicErrorCode));
MOCK_METHOD1(
(StreamId, QuicErrorCode));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setPingCallback,
folly::Expected<folly::Unit, LocalErrorCode>(PingCallback*));
MOCK_METHOD1(sendPing, void(std::chrono::milliseconds));
MOCK_CONST_METHOD0(getState, const QuicConnectionStateBase*());
MOCK_METHOD0(isDetachable, bool());
MOCK_METHOD1(attachEventBase, void(folly::EventBase*));
MOCK_METHOD0(detachEventBase, void());
MOCK_METHOD1(setControlStream, folly::Optional<LocalErrorCode>(StreamId));
(PingCallback*));
MOCK_METHOD(void, sendPing, (std::chrono::milliseconds));
MOCK_METHOD(const QuicConnectionStateBase*, getState, (), (const));
MOCK_METHOD(bool, isDetachable, ());
MOCK_METHOD(void, attachEventBase, (folly::EventBase*));
MOCK_METHOD(void, detachEventBase, ());
MOCK_METHOD(folly::Optional<LocalErrorCode>, setControlStream, (StreamId));
MOCK_METHOD2(
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
setPeekCallback,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId, PeekCallback*));
(StreamId, PeekCallback*));
MOCK_METHOD1(
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
pausePeek,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
MOCK_METHOD1(
(StreamId));
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
resumePeek,
folly::Expected<folly::Unit, LocalErrorCode>(StreamId));
(StreamId));
MOCK_METHOD2(
MOCK_METHOD(
(folly::Expected<folly::Unit, LocalErrorCode>),
peek,
folly::Expected<folly::Unit, LocalErrorCode>(
StreamId,
const folly::Function<
void(StreamId, const folly::Range<PeekIterator>&) const>&));
(StreamId,
const folly::Function<void(StreamId, const folly::Range<PeekIterator>&)
const>&));
MOCK_METHOD3(
consume,
folly::Expected<
MOCK_METHOD(
(folly::Expected<
folly::Unit,
std::pair<LocalErrorCode, folly::Optional<uint64_t>>>(
StreamId,
uint64_t,
size_t));
MOCK_METHOD2(
std::pair<LocalErrorCode, folly::Optional<uint64_t>>>),
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_;
ConnectionCallback* connCb_;
@ -298,28 +314,32 @@ class MockQuicSocket : public QuicSocket {
earlyDataAppParamsValidator_;
folly::Function<Buf()> 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<folly::Unit, LocalErrorCode>),
setDatagramCallback,
folly::Expected<folly::Unit, LocalErrorCode>(DatagramCallback*));
MOCK_CONST_METHOD0(getDatagramSizeLimit, uint16_t());
(DatagramCallback*));
MOCK_METHOD(uint16_t, getDatagramSizeLimit, (), (const));
folly::Expected<folly::Unit, LocalErrorCode> 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<std::vector<ReadDatagram>, LocalErrorCode>),
readDatagrams,
folly::Expected<std::vector<ReadDatagram>, LocalErrorCode>(size_t));
MOCK_METHOD1(
(size_t));
MOCK_METHOD(
(folly::Expected<std::vector<Buf>, LocalErrorCode>),
readDatagramBufs,
folly::Expected<std::vector<Buf>, LocalErrorCode>(size_t));
(size_t));
};
} // namespace quic

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

@ -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<PeekIterator>&),
(noexcept));
MOCK_METHOD((void), peekError, (StreamId, QuicError), (noexcept));
#else
GMOCK_METHOD2_(
,
noexcept,
,
onDataAvailable,
void(StreamId, const folly::Range<PeekIterator>&));
GMOCK_METHOD2_(, noexcept, , peekError, void(StreamId, QuicError));
#endif
};
class MockDatagramCallback : public QuicSocket::DatagramCallback {
public:
~MockDatagramCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onDatagramsAvailable, (), (noexcept));
#else
GMOCK_METHOD0_(, noexcept, , onDatagramsAvailable, void());
#endif
};
class MockWriteCallback : public QuicSocket::WriteCallback {
public:
~MockWriteCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onStreamWriteReady, (StreamId, uint64_t), (noexcept));
MOCK_METHOD((void), onConnectionWriteReady, (uint64_t), (noexcept));
MOCK_METHOD((void), onStreamWriteError, (StreamId, QuicError), (noexcept));
MOCK_METHOD((void), onConnectionWriteError, (QuicError), (noexcept));
#else
GMOCK_METHOD2_(, noexcept, , onStreamWriteReady, void(StreamId, uint64_t));
GMOCK_METHOD1_(, noexcept, , onConnectionWriteReady, void(uint64_t));
GMOCK_METHOD2_(, noexcept, , onStreamWriteError, void(StreamId, QuicError));
GMOCK_METHOD1_(, noexcept, , onConnectionWriteError, void(QuicError));
#endif
};
class MockConnectionSetupCallback : public QuicSocket::ConnectionSetupCallback {
public:
~MockConnectionSetupCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onConnectionSetupError, (QuicError), (noexcept));
MOCK_METHOD((void), onReplaySafe, (), (noexcept));
MOCK_METHOD((void), onTransportReady, (), (noexcept));
MOCK_METHOD((void), onFirstPeerPacketProcessed, (), (noexcept));
#else
GMOCK_METHOD1_(, noexcept, , onConnectionSetupError, void(QuicError));
GMOCK_METHOD0_(, noexcept, , onReplaySafe, void());
GMOCK_METHOD0_(, noexcept, , onTransportReady, void());
GMOCK_METHOD0_(, noexcept, , onFirstPeerPacketProcessed, void());
#endif
};
class MockConnectionCallback : public QuicSocket::ConnectionCallback {
public:
~MockConnectionCallback() override = default;
#if defined(MOCK_METHOD)
MOCK_METHOD((void), onFlowControlUpdate, (StreamId), (noexcept));
MOCK_METHOD((void), onNewBidirectionalStream, (StreamId), (noexcept));
MOCK_METHOD((void), onNewUnidirectionalStream, (StreamId), (noexcept));
@ -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<QuicVersion>&));
GMOCK_METHOD1_(
,
noexcept,
,
setServerConnectionIdParams,
void(ServerConnectionIdParams));
GMOCK_METHOD1_(, noexcept, , close, void(folly::Optional<QuicError>));
GMOCK_METHOD1_(, noexcept, , closeNow, void(folly::Optional<QuicError>));
GMOCK_METHOD0_(, const, , hasShutdown, bool());
GMOCK_METHOD0_(
,
const,
,
getClientConnectionId,
folly::Optional<ConnectionId>());
GMOCK_METHOD0_(
,
const,
,
getClientChosenDestConnectionId,
folly::Optional<ConnectionId>());
GMOCK_METHOD1_(
,
noexcept,
,
setTransportStatsCallback,
void(QuicTransportStatsCallback*));
GMOCK_METHOD1_(, noexcept, , setConnectionIdAlgo, void(ConnectionIdAlgo*));
#endif
void onNetworkData(
const folly::SocketAddress& peer,
NetworkData&& networkData) noexcept override {
onNetworkData(peer, networkData);
}
MOCK_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<QuicError>&));
GMOCK_METHOD2_(
,
noexcept,
,
startWritingFromAppLimited,
void(QuicSocket*, const AppLimitedEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
packetsWritten,
void(QuicSocket*, const PacketsWrittenEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
appRateLimited,
void(QuicSocket*, const AppLimitedEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
acksProcessed,
void(QuicSocket*, const AcksProcessedEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
packetLossDetected,
void(QuicSocket*, const LossEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
rttSampleGenerated,
void(QuicSocket*, const PacketRTT&));
GMOCK_METHOD1_(, noexcept, , pmtuProbingStarted, void(QuicSocket*));
GMOCK_METHOD2_(
,
noexcept,
,
pmtuBlackholeDetected,
void(QuicSocket*, const PMTUBlackholeEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
pmtuUpperBoundDetected,
void(QuicSocket*, const PMTUUpperBoundEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
spuriousLossDetected,
void(QuicSocket*, const SpuriousLossEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
knobFrameReceived,
void(QuicSocket*, const KnobFrameEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
streamOpened,
void(QuicSocket*, const StreamOpenEvent&));
GMOCK_METHOD2_(
,
noexcept,
,
streamClosed,
void(QuicSocket*, const StreamCloseEvent&));
#endif
static auto getLossPacketNum(PacketNum packetNum) {
return testing::Field(

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

@ -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));

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

@ -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));

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

@ -542,7 +542,7 @@ class QuicTransportImplTest : public Test {
class QuicTransportImplTestClose : public QuicTransportImplTest,
public testing::WithParamInterface<bool> {};
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));

1
quic/client/QuicClientAsyncTransport.h
View File

@ -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));

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

@ -21,9 +21,10 @@ namespace test {
class MockClientHandshakeFactory : public ClientHandshakeFactory {
public:
MOCK_METHOD1(
MOCK_METHOD(
std::unique_ptr<ClientHandshake>,
_makeClientHandshake,
std::unique_ptr<ClientHandshake>(QuicClientConnectionState*));
(QuicClientConnectionState*));
std::unique_ptr<ClientHandshake>
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<std::string>&));
MOCK_CONST_METHOD0(getCryptoFactory, const CryptoFactory&());
MOCK_CONST_METHOD0(isTLSResumed, bool());
MOCK_METHOD0(getZeroRttRejected, folly::Optional<bool>());
MOCK_METHOD0(
(const ConnectionId&, const RetryPacket&));
MOCK_METHOD(void, removePsk, (const folly::Optional<std::string>&));
MOCK_METHOD(const CryptoFactory&, getCryptoFactory, (), (const));
MOCK_METHOD(bool, isTLSResumed, (), (const));
MOCK_METHOD(folly::Optional<bool>, getZeroRttRejected, ());
MOCK_METHOD(
folly::Optional<ServerTransportParameters>,
getServerTransportParams,
folly::Optional<ServerTransportParameters>());
MOCK_METHOD0(destroy, void());
());
MOCK_METHOD(void, destroy, ());
MOCK_METHOD1(
MOCK_METHOD(
folly::Optional<CachedServerTransportParameters>,
connectImpl,
folly::Optional<CachedServerTransportParameters>(
folly::Optional<std::string>));
MOCK_METHOD0(getReadRecordLayerEncryptionLevel, EncryptionLevel());
MOCK_METHOD1(processSocketData, void(folly::IOBufQueue& queue));
MOCK_METHOD0(matchEarlyParameters, bool());
MOCK_METHOD2(
(folly::Optional<std::string>));
MOCK_METHOD(EncryptionLevel, getReadRecordLayerEncryptionLevel, ());
MOCK_METHOD(void, processSocketData, (folly::IOBufQueue & queue));
MOCK_METHOD(bool, matchEarlyParameters, ());
MOCK_METHOD(
(std::pair<std::unique_ptr<Aead>, std::unique_ptr<PacketNumberCipher>>),
buildCiphers,
std::pair<std::unique_ptr<Aead>, std::unique_ptr<PacketNumberCipher>>(
ClientHandshake::CipherKind kind,
folly::ByteRange secret));
MOCK_CONST_METHOD0(
(ClientHandshake::CipherKind kind, folly::ByteRange secret));
MOCK_METHOD(
const folly::Optional<std::string>&,
getApplicationProtocol,
const folly::Optional<std::string>&());
(),
(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 {

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

@ -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<ServerConnectionIdParams, QuicInternalException>),
parseConnectionId,
folly::Expected<ServerConnectionIdParams, QuicInternalException>(
const ConnectionId&));
GMOCK_METHOD1_(
,
noexcept,
,
(const ConnectionId&),
(noexcept));
MOCK_METHOD(
(folly::Expected<ConnectionId, QuicInternalException>),
encodeConnectionId,
folly::Expected<ConnectionId, QuicInternalException>(
const ServerConnectionIdParams&));
(const ServerConnectionIdParams&),
(noexcept));
bool canParse(const ConnectionId& id) const noexcept override {
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 {
_insert(buf, limit);
}
MOCK_METHOD1(appendFrame, void(QuicWriteFrame));
MOCK_METHOD1(_insert, void(std::unique_ptr<folly::IOBuf>&));
MOCK_METHOD2(_insert, void(std::unique_ptr<folly::IOBuf>&, size_t));
MOCK_METHOD2(insert, void(const BufQueue&, size_t));
MOCK_METHOD2(push, void(const uint8_t*, size_t));
MOCK_METHOD1(write, void(const QuicInteger&));
MOCK_METHOD(void, appendFrame, (QuicWriteFrame));
MOCK_METHOD(void, _insert, (std::unique_ptr<folly::IOBuf>&));
MOCK_METHOD(void, _insert, (std::unique_ptr<folly::IOBuf>&, size_t));
MOCK_METHOD(void, insert, (const BufQueue&, size_t));
MOCK_METHOD(void, push, (const uint8_t*, size_t));
MOCK_METHOD(void, write, (const QuicInteger&));
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();

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

@ -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(

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

@ -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(

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

@ -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));

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

@ -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) {

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

@ -329,9 +329,11 @@ class FizzCryptoTestFactory : public FizzCryptoFactory {
std::unique_ptr<PacketNumberCipher> makePacketNumberCipher(
fizz::CipherSuite) const override;
MOCK_CONST_METHOD1(
MOCK_METHOD(
std::unique_ptr<PacketNumberCipher>,
_makePacketNumberCipher,
std::unique_ptr<PacketNumberCipher>(folly::ByteRange));
(folly::ByteRange),
(const));
std::unique_ptr<PacketNumberCipher> makePacketNumberCipher(
folly::ByteRange secret) const override;
@ -397,7 +399,7 @@ class FakeServerHandshake : public FizzServerHandshake {
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)
override {

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

@ -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

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

@ -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<uint16_t>,
raiseProbeSize,
folly::Optional<uint16_t>(uint16_t lastProbeSize));
(uint16_t lastProbeSize));
};
} // namespace test

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

@ -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<MockDSRPacketBuilder&>(*this).remainingSpaceNonConst();
}
MOCK_METHOD2(addSendInstruction, void(SendInstruction&&, uint32_t));
MOCK_METHOD(void, addSendInstruction, (SendInstruction&&, uint32_t));
};
} // namespace quic::test

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

@ -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

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

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

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

@ -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<QuicSocket> 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<uint8_t> {};
INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_SUITE_P(
QuicClientZeroLenConnIds,
QuicClientTransportAfterStartTest,
::Values(0, 8));
@ -3010,7 +3009,7 @@ class QuicClientTransportAfterStartTestClose
: public QuicClientTransportAfterStartTestBase,
public testing::WithParamInterface<bool> {};
INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_SUITE_P(
QuicClientTransportAfterStartTestCloseWithError,
QuicClientTransportAfterStartTestClose,
Values(true, false));
@ -3216,7 +3215,7 @@ class QuicClientTransportAfterStartTestTimeout
: public QuicClientTransportAfterStartTestBase,
public testing::WithParamInterface<QuicVersion> {};
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));

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

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

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

@ -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<TrafficKey>());
MOCK_CONST_METHOD3(
MOCK_METHOD(folly::Optional<TrafficKey>, getKey, (), (const));
MOCK_METHOD(
std::unique_ptr<folly::IOBuf>,
_inplaceEncrypt,
std::unique_ptr<folly::IOBuf>(
std::unique_ptr<folly::IOBuf>& plaintext,
const folly::IOBuf* associatedData,
uint64_t seqNum));
(std::unique_ptr<folly::IOBuf> & plaintext,
const folly::IOBuf* associatedData,
uint64_t seqNum),
(const));
std::unique_ptr<folly::IOBuf> inplaceEncrypt(
std::unique_ptr<folly::IOBuf>&& 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<folly::IOBuf>,
_decrypt,
std::unique_ptr<folly::IOBuf>(
std::unique_ptr<folly::IOBuf>& ciphertext,
const folly::IOBuf* associatedData,
uint64_t seqNum));
(std::unique_ptr<folly::IOBuf> & ciphertext,
const folly::IOBuf* associatedData,
uint64_t seqNum),
(const));
std::unique_ptr<folly::IOBuf> decrypt(
std::unique_ptr<folly::IOBuf>&& 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<std::unique_ptr<folly::IOBuf>>,
_tryDecrypt,
folly::Optional<std::unique_ptr<folly::IOBuf>>(
std::unique_ptr<folly::IOBuf>& ciphertext,
const folly::IOBuf* associatedData,
uint64_t seqNum));
(std::unique_ptr<folly::IOBuf> & ciphertext,
const folly::IOBuf* associatedData,
uint64_t seqNum),
(const));
folly::Optional<std::unique_ptr<folly::IOBuf>> tryDecrypt(
std::unique_ptr<folly::IOBuf>&& ciphertext,
const folly::IOBuf* associatedData,

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

@ -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<std::chrono::milliseconds>));
MOCK_METHOD2(
(quic::StreamId,
std::string,
folly::Optional<std::chrono::milliseconds>));
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<ConnectionId>));
MOCK_METHOD1(setScid, void(folly::Optional<ConnectionId>));
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<ConnectionId>));
MOCK_METHOD(void, setScid, (folly::Optional<ConnectionId>));
MOCK_METHOD(void, addPriorityUpdate, (quic::StreamId, uint8_t, bool));
};
} // namespace quic::test

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

@ -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(

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

@ -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 {

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

@ -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<MockServerConnectionIdRejector&>(*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<const fizz::server::FizzServerContext>),
(noexcept));
#else
GMOCK_METHOD4_(
,
noexcept,
,
_make,
QuicServerTransport::Ptr(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket>& sock,
const folly::SocketAddress&,
std::shared_ptr<const fizz::server::FizzServerContext>));
#endif
};
class MockWorkerCallback : public QuicServerWorker::WorkerCallback {
public:
~MockWorkerCallback() = default;
MOCK_METHOD1(handleWorkerError, void(LocalErrorCode));
MOCK_METHOD(void, handleWorkerError, (LocalErrorCode));
MOCK_METHOD5(
MOCK_METHOD(
void,
routeDataToWorkerLong,
void(
const folly::SocketAddress&,
std::unique_ptr<RoutingData>&,
std::unique_ptr<NetworkData>&,
folly::Optional<QuicVersion>,
bool isForwardedData));
(const folly::SocketAddress&,
std::unique_ptr<RoutingData>&,
std::unique_ptr<NetworkData>&,
folly::Optional<QuicVersion>,
bool isForwardedData));
MOCK_METHOD5(
MOCK_METHOD(
void,
routeDataToWorkerShort,
void(
const folly::SocketAddress&,
std::unique_ptr<RoutingData>&,
std::unique_ptr<NetworkData>&,
folly::Optional<QuicVersion>,
bool isForwardedData));
(const folly::SocketAddress&,
std::unique_ptr<RoutingData>&,
std::unique_ptr<NetworkData>&,
folly::Optional<QuicVersion>,
bool isForwardedData));
void routeDataToWorker(
const folly::SocketAddress& client,
@ -124,14 +102,13 @@ class MockQuicUDPSocketFactory : public QuicUDPSocketFactory {
std::unique_ptr<folly::AsyncUDPSocket> make(folly::EventBase* evb, int fd) {
return std::unique_ptr<folly::AsyncUDPSocket>(_make(evb, fd));
}
MOCK_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<ConnectionIdData>&),
(noexcept));
#else
GMOCK_METHOD2_(
,
noexcept,
,
onConnectionIdAvailable,
void(QuicServerTransport::Ptr, ConnectionId));
GMOCK_METHOD1_(
,
noexcept,
,
onConnectionIdBound,
void(QuicServerTransport::Ptr));
GMOCK_METHOD3_(
,
noexcept,
,
onConnectionUnbound,
void(
QuicServerTransport*,
const QuicServerTransport::SourceIdentity&,
const std::vector<ConnectionIdData>& connIdData));
#endif
};
class MockHandshakeFinishedCallback
@ -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 {

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

@ -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) {

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

@ -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<folly::IPAddress> expectedSourceToken_;
};
INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_SUITE_P(
QuicServerTransportHandshakeTests,
QuicServerTransportHandshakeTest,
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,
AckHandlersTest,
Values(

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

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

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

@ -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

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

@ -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(