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

Use folly::ObserverContainer for socket observer [2/x]

Browse Source 
Summary:
This diff is part of larger change to switch to using `folly::ObserverContainer` (introduced in D27062840).

This diff:
- Renames `quic::Observer` to `quic::LegacyObserver`.
- Switches to using `quic::SocketObserverInterface` instead of `quic::Observer` when referencing structures used for the observer interface. For instance, `quic::Observer::WriteEvent` changes to `quic::SocketObserverInterface::WriteEvent`.

Differential Revision: D35000152

fbshipit-source-id: f387231fd58e8e763c3d7ed0a9c6fcec3b2324e2
This commit is contained in:
Brandon Schlinker
2022-04-18 04:19:31 -07:00
committed by Facebook GitHub Bot
parent cfa3cb9c7b
commit ea056eb960
18 changed files with 652 additions and 507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
quic/api/Observer.h
View File

@@ -29,7 +29,7 @@ class QuicSocket;
/**
* Observer of socket events.
*/
class Observer : public SocketObserverInterface {
class LegacyObserver : public SocketObserverInterface {
public:
/**
* Observer configuration.
@@ -78,17 +78,17 @@ class Observer : public SocketObserverInterface {
/**
* Constructor for observer, uses default config (all callbacks disabled).
*/
Observer() : Observer(Config()) {}
LegacyObserver() : LegacyObserver(Config()) {}
/**
* Constructor for observer.
*
* @param config Config, defaults to auxilary instrumentaton disabled.
*/
explicit Observer(const Config& observerConfig)
explicit LegacyObserver(const Config& observerConfig)
: observerConfig_(observerConfig) {}
~Observer() override = default;
~LegacyObserver() override = default;
/**
* Returns observers configuration.
@@ -130,6 +130,6 @@ class Observer : public SocketObserverInterface {
// Container for instrumentation observers.
// Avoids heap allocation for up to 2 observers being installed.
using ObserverVec = SmallVec<Observer*, 2>;
using ObserverVec = SmallVec<LegacyObserver*, 2>;
} // namespace quic

4
quic/api/QuicSocket.h
View File

@@ -1191,7 +1191,7 @@ class QuicSocket {
*
* @param observer Observer to add (implements Observer).
*/
virtual void addObserver(Observer* observer) = 0;
virtual void addObserver(LegacyObserver* observer) = 0;
/**
* Removes an observer.
@@ -1199,7 +1199,7 @@ class QuicSocket {
* @param observer Observer to remove.
* @return Whether observer found and removed from list.
*/
virtual bool removeObserver(Observer* observer) = 0;
virtual bool removeObserver(LegacyObserver* observer) = 0;
/**
* Returns installed observers.

23
quic/api/QuicTransportBase.cpp
View File

@@ -1487,7 +1487,9 @@ void QuicTransportBase::handleKnobCallbacks() {
for (const auto& cb : *observers_) {
if (cb->getConfig().knobFrameEvents) {
cb->knobFrameReceived(
this, quic::Observer::KnobFrameEvent(Clock::now(), knobFrame));
this,
quic::SocketObserverInterface::KnobFrameEvent(
Clock::now(), knobFrame));
}
}
@@ -1507,7 +1509,8 @@ void QuicTransportBase::handleAckEventCallbacks() {
return; // nothing to do
}
const auto event = quic::Observer::AcksProcessedEvent::Builder()
const auto event =
quic::SocketObserverInterface::AcksProcessedEvent::Builder()
.setAckEvents(lastProcessedAckEvents)
.build();
for (const auto& cb : *observers_) {
@@ -1541,7 +1544,7 @@ void QuicTransportBase::handleNewStreamCallbacks(
} else {
connCallback_->onNewUnidirectionalStream(streamId);
}
const Observer::StreamOpenEvent streamEvent(
const SocketObserverInterface::StreamOpenEvent streamEvent(
streamId,
getStreamInitiator(streamId),
getStreamDirectionality(streamId));
@@ -1883,7 +1886,7 @@ QuicTransportBase::createStreamInternal(bool bidirectional) {
}
if (streamResult) {
const StreamId streamId = streamResult.value()->id;
const Observer::StreamOpenEvent streamEvent(
const SocketObserverInterface::StreamOpenEvent streamEvent(
streamId,
getStreamInitiator(streamId),
getStreamDirectionality(streamId));
@@ -2391,7 +2394,7 @@ void QuicTransportBase::checkForClosedStream() {
auto itr = conn_->streamManager->closedStreams().begin();
while (itr != conn_->streamManager->closedStreams().end()) {
const auto& streamId = *itr;
const Observer::StreamCloseEvent streamEvent(
const SocketObserverInterface::StreamCloseEvent streamEvent(
streamId,
getStreamInitiator(streamId),
getStreamDirectionality(streamId));
@@ -2826,7 +2829,7 @@ void QuicTransportBase::resetNonControlStreams(
}
}
void QuicTransportBase::addObserver(Observer* observer) {
void QuicTransportBase::addObserver(LegacyObserver* observer) {
// adding the same observer multiple times is not allowed
CHECK(
std::find(observers_->begin(), observers_->end(), observer) ==
@@ -2836,7 +2839,7 @@ void QuicTransportBase::addObserver(Observer* observer) {
observer->observerAttach(this);
}
bool QuicTransportBase::removeObserver(Observer* observer) {
bool QuicTransportBase::removeObserver(LegacyObserver* observer) {
auto it = std::find(observers_->begin(), observers_->end(), observer);
if (it == observers_->end()) {
return false;
@@ -3546,7 +3549,7 @@ QuicSocket::WriteResult QuicTransportBase::setDSRPacketizationRequestSender(
void QuicTransportBase::notifyStartWritingFromAppRateLimited() {
const auto event =
Observer::AppLimitedEvent::Builder()
SocketObserverInterface::AppLimitedEvent::Builder()
.setOutstandingPackets(conn_->outstandings.packets)
.setWriteCount(conn_->writeCount)
.setLastPacketSentTime(conn_->lossState.maybeLastPacketSentTime)
@@ -3573,7 +3576,7 @@ void QuicTransportBase::notifyPacketsWritten(
uint64_t numAckElicitingPacketsWritten,
uint64_t numBytesWritten) {
const auto event =
Observer::PacketsWrittenEvent::Builder()
SocketObserverInterface::PacketsWrittenEvent::Builder()
.setOutstandingPackets(conn_->outstandings.packets)
.setWriteCount(conn_->writeCount)
.setLastPacketSentTime(conn_->lossState.maybeLastPacketSentTime)
@@ -3600,7 +3603,7 @@ void QuicTransportBase::notifyPacketsWritten(
void QuicTransportBase::notifyAppRateLimited() {
const auto event =
Observer::AppLimitedEvent::Builder()
SocketObserverInterface::AppLimitedEvent::Builder()
.setOutstandingPackets(conn_->outstandings.packets)
.setWriteCount(conn_->writeCount)
.setLastPacketSentTime(conn_->lossState.maybeLastPacketSentTime)

4
quic/api/QuicTransportBase.h
View File

@@ -652,7 +652,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
*
* @param observer Observer to add (implements Observer).
*/
void addObserver(Observer* observer) override;
void addObserver(LegacyObserver* observer) override;
/**
* Removes an observer.
@@ -660,7 +660,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
* @param observer Observer to remove.
* @return Whether observer found and removed from list.
*/
bool removeObserver(Observer* observer) override;
bool removeObserver(LegacyObserver* observer) override;
/**
* Returns installed observers.

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

@@ -308,8 +308,8 @@ class MockQuicSocket : public QuicSocket {
earlyDataAppParamsValidator_;
folly::Function<Buf()> earlyDataAppParamsGetter_;
MOCK_METHOD(void, addObserver, (Observer*));
MOCK_METHOD(bool, removeObserver, (Observer*));
MOCK_METHOD(void, addObserver, (LegacyObserver*));
MOCK_METHOD(bool, removeObserver, (LegacyObserver*));
MOCK_METHOD(const ObserverVec&, getObservers, (), (const));
MOCK_METHOD(
void,

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

@@ -258,11 +258,11 @@ class MockLoopDetectorCallback : public LoopDetectorCallback {
MOCK_METHOD(void, onSuspiciousReadLoops, (uint64_t, NoReadReason));
};
class MockObserver : public Observer {
class MockLegacyObserver : public LegacyObserver {
public:
MockObserver() : Observer(Observer::Config()) {}
MockObserver(const Observer::Config& observerConfig)
: Observer(observerConfig) {}
MockLegacyObserver() : LegacyObserver(LegacyObserver::Config()) {}
explicit MockLegacyObserver(const LegacyObserver::Config& observerConfig)
: LegacyObserver(observerConfig) {}
MOCK_METHOD((void), observerAttach, (QuicSocket*), (noexcept));
MOCK_METHOD((void), observerDetach, (QuicSocket*), (noexcept));
MOCK_METHOD((void), destroy, (QuicSocket*), (noexcept));
@@ -349,12 +349,14 @@ class MockObserver : public Observer {
bool timeoutLoss) {
return AllOf(
testing::Field(
&Observer::LostPacket::lostByReorderThreshold,
&SocketObserverInterface::LostPacket::lostByReorderThreshold,
testing::Eq(reorderLoss)),
testing::Field(
&Observer::LostPacket::lostByTimeout, testing::Eq(timeoutLoss)),
&SocketObserverInterface::LostPacket::lostByTimeout,
testing::Eq(timeoutLoss)),
testing::Field(
&Observer::LostPacket::packet, getLossPacketNum(packetNum)));
&SocketObserverInterface::LostPacket::packet,
getLossPacketNum(packetNum)));
}
static auto getStreamEventMatcher(

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

@@ -3482,9 +3482,9 @@ TEST_F(QuicTransportImplTest, HandleKnobCallbacks) {
auto conn = transport->transportConn;
// attach an observer to the socket
Observer::Config config = {};
LegacyObserver::Config config = {};
config.knobFrameEvents = true;
auto cb = std::make_unique<StrictMock<MockObserver>>(config);
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>(config);
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
Mock::VerifyAndClearExpectations(cb.get());
@@ -3547,7 +3547,7 @@ TEST_F(QuicTransportImplTest, StreamWriteCallbackUnregister) {
}
TEST_F(QuicTransportImplTest, ObserverAttachRemove) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3558,13 +3558,13 @@ TEST_F(QuicTransportImplTest, ObserverAttachRemove) {
}
TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultiple) {
auto cb1 = std::make_unique<StrictMock<MockObserver>>();
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb1, observerAttach(transport.get()));
transport->addObserver(cb1.get());
Mock::VerifyAndClearExpectations(cb1.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
auto cb2 = std::make_unique<StrictMock<MockObserver>>();
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb2, observerAttach(transport.get()));
transport->addObserver(cb2.get());
Mock::VerifyAndClearExpectations(cb2.get());
@@ -3583,13 +3583,13 @@ TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultiple) {
}
TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultipleReverse) {
auto cb1 = std::make_unique<StrictMock<MockObserver>>();
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb1, observerAttach(transport.get()));
transport->addObserver(cb1.get());
Mock::VerifyAndClearExpectations(cb1.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
auto cb2 = std::make_unique<StrictMock<MockObserver>>();
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb2, observerAttach(transport.get()));
transport->addObserver(cb2.get());
Mock::VerifyAndClearExpectations(cb2.get());
@@ -3608,13 +3608,13 @@ TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultipleReverse) {
}
TEST_F(QuicTransportImplTest, ObserverRemoveMissing) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_FALSE(transport->removeObserver(cb.get()));
EXPECT_THAT(transport->getObservers(), IsEmpty());
}
TEST_F(QuicTransportImplTest, ObserverDestroyTransport) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3626,7 +3626,7 @@ TEST_F(QuicTransportImplTest, ObserverDestroyTransport) {
}
TEST_F(QuicTransportImplTest, ObserverCloseNoErrorThenDestroyTransport) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3645,7 +3645,7 @@ TEST_F(QuicTransportImplTest, ObserverCloseNoErrorThenDestroyTransport) {
}
TEST_F(QuicTransportImplTest, ObserverCloseWithErrorThenDestroyTransport) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3664,7 +3664,7 @@ TEST_F(QuicTransportImplTest, ObserverCloseWithErrorThenDestroyTransport) {
}
TEST_F(QuicTransportImplTest, ObserverDetachObserverImmediately) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3676,7 +3676,7 @@ TEST_F(QuicTransportImplTest, ObserverDetachObserverImmediately) {
}
TEST_F(QuicTransportImplTest, ObserverDetachObserverAfterTransportClose) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3694,7 +3694,7 @@ TEST_F(QuicTransportImplTest, ObserverDetachObserverAfterTransportClose) {
TEST_F(
QuicTransportImplTest,
ObserverDetachObserverOnCloseDuringTransportDestroy) {
auto cb = std::make_unique<StrictMock<MockObserver>>();
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb, observerAttach(transport.get()));
transport->addObserver(cb.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3710,12 +3710,12 @@ TEST_F(
}
TEST_F(QuicTransportImplTest, ObserverMultipleAttachRemove) {
auto cb1 = std::make_unique<StrictMock<MockObserver>>();
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb1, observerAttach(transport.get()));
transport->addObserver(cb1.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
auto cb2 = std::make_unique<StrictMock<MockObserver>>();
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb2, observerAttach(transport.get()));
transport->addObserver(cb2.get());
EXPECT_THAT(
@@ -3737,12 +3737,12 @@ TEST_F(QuicTransportImplTest, ObserverMultipleAttachRemove) {
}
TEST_F(QuicTransportImplTest, ObserverMultipleAttachDestroyTransport) {
auto cb1 = std::make_unique<StrictMock<MockObserver>>();
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb1, observerAttach(transport.get()));
transport->addObserver(cb1.get());
EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
auto cb2 = std::make_unique<StrictMock<MockObserver>>();
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*cb2, observerAttach(transport.get()));
transport->addObserver(cb2.get());
EXPECT_THAT(
@@ -3759,9 +3759,9 @@ TEST_F(QuicTransportImplTest, ObserverMultipleAttachDestroyTransport) {
}
TEST_F(QuicTransportImplTest, ObserverDetachAndAttachEvb) {
Observer::Config config = {};
LegacyObserver::Config config = {};
config.evbEvents = true;
auto cb = std::make_unique<StrictMock<MockObserver>>(config);
auto cb = std::make_unique<StrictMock<MockLegacyObserver>>(config);
folly::EventBase evb2;
EXPECT_CALL(*cb, observerAttach(transport.get()));

406
quic/api/test/QuicTransportTest.cpp
View File

@@ -376,12 +376,13 @@ TEST_F(QuicTransportTest, ObserverNotAppLimitedWithNoWritableBytes) {
return 0;
}));
Observer::Config config = {};
LegacyObserver::Config config = {};
config.packetsWrittenEvents = true;
config.appRateLimitedEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
EXPECT_CALL(*cb1, observerAttach(transport_.get()));
EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -421,12 +422,13 @@ TEST_F(QuicTransportTest, ObserverNotAppLimitedWithLargeBuffer) {
EXPECT_CALL(*rawCongestionController, getWritableBytes())
.WillRepeatedly(Return(5000));
Observer::Config config = {};
LegacyObserver::Config config = {};
config.packetsWrittenEvents = true;
config.appRateLimitedEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
EXPECT_CALL(*cb1, observerAttach(transport_.get()));
EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -458,12 +460,13 @@ TEST_F(QuicTransportTest, ObserverNotAppLimitedWithLargeBuffer) {
}
TEST_F(QuicTransportTest, ObserverAppLimited) {
Observer::Config config = {};
LegacyObserver::Config config = {};
config.packetsWrittenEvents = true;
config.appRateLimitedEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
EXPECT_CALL(*cb1, observerAttach(transport_.get()));
EXPECT_CALL(*cb2, observerAttach(transport_.get()));
EXPECT_CALL(*cb3, observerAttach(transport_.get()));
@@ -506,26 +509,27 @@ TEST_F(QuicTransportTest, ObserverAppLimited) {
TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
InSequence s;
Observer::Config config = {};
LegacyObserver::Config config = {};
config.packetsWrittenEvents = true;
config.appRateLimitedEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
const auto invokeForAllObservers =
[&cb1, &cb2, &cb3](const std::function<void(MockObserver&)>& fn) {
[&cb1, &cb2, &cb3](const std::function<void(MockLegacyObserver&)>& fn) {
fn(*cb1);
fn(*cb2);
fn(*cb3);
};
const auto invokeForEachObserverWithTestEvents =
[&cb1, &cb2](const std::function<void(MockObserver&)>& fn) {
[&cb1, &cb2](const std::function<void(MockLegacyObserver&)>& fn) {
fn(*cb1);
fn(*cb2);
};
// install observers
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, observerAttach(transport_.get()));
transport_->addObserver(&observer);
}));
@@ -547,25 +551,29 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
{
const auto writeEventMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(0)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(0)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)));
const auto packetsWrittenEventMatcher = AllOf(
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(0)));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher](MockObserver& observer) {
([this, &writeEventMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
startWritingFromAppLimited(transport_.get(), writeEventMatcher));
}));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher, &packetsWrittenEventMatcher](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
packetsWritten(
@@ -573,7 +581,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
}));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher](MockObserver& observer) {
([this, &writeEventMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer, appRateLimited(transport_.get(), writeEventMatcher));
}));
@@ -610,12 +618,14 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
{
const auto writeEventMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(0)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(0)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)));
invokeForEachObserverWithTestEvents(([this, &writeEventMatcher](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
startWritingFromAppLimited(transport_.get(), writeEventMatcher));
@@ -626,20 +636,23 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
{
const auto writeEventMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(5)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)));
const auto packetsWrittenEventMatcher = AllOf(
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(5)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(5)));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher, &packetsWrittenEventMatcher](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
packetsWritten(
@@ -654,20 +667,23 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
{
const auto writeEventMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(7)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(7)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)));
const auto packetsWrittenEventMatcher = AllOf(
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(2)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(2)));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher, &packetsWrittenEventMatcher](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
packetsWritten(
@@ -675,7 +691,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
}));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher](MockObserver& observer) {
([this, &writeEventMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer, appRateLimited(transport_.get(), writeEventMatcher));
}));
@@ -710,12 +726,14 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
{
const auto writeEventMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(7)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(7)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)));
invokeForEachObserverWithTestEvents(([this, &writeEventMatcher](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
startWritingFromAppLimited(transport_.get(), writeEventMatcher));
@@ -727,9 +745,9 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
{
// older versions of gtest do not seem to accept lambdas for ResultOf
// matcher, so define an std::function
std::function<uint64_t(const Observer::WriteEvent&)>
std::function<uint64_t(const SocketObserverInterface::WriteEvent&)>
countPacketsWithAckFrames =
[](const Observer::WriteEvent& event) -> uint64_t {
[](const SocketObserverInterface::WriteEvent& event) -> uint64_t {
uint64_t packetsWithAckFrames = 0;
for (auto& outstandingPacket : event.outstandingPackets) {
bool hasAckFrame = false;
@@ -749,20 +767,23 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
const auto writeEventMatcher = AllOf(
testing::ResultOf(countPacketsWithAckFrames, 1),
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(9)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(9)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)));
const auto packetsWrittenEventMatcher = AllOf(
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(2)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(2)));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher, &packetsWrittenEventMatcher](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
packetsWritten(
@@ -770,7 +791,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
}));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher](MockObserver& observer) {
([this, &writeEventMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer, appRateLimited(transport_.get(), writeEventMatcher));
}));
@@ -810,25 +831,29 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
const auto writeEventMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(9)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(9)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)));
const auto packetsWrittenEventMatcher = AllOf(
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(0)));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher](MockObserver& observer) {
([this, &writeEventMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
startWritingFromAppLimited(transport_.get(), writeEventMatcher));
}));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher, &packetsWrittenEventMatcher](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
packetsWritten(
@@ -836,7 +861,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
}));
invokeForEachObserverWithTestEvents(
([this, &writeEventMatcher](MockObserver& observer) {
([this, &writeEventMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer, appRateLimited(transport_.get(), writeEventMatcher));
}));
@@ -856,10 +881,10 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
transport_->updateWriteLooper(true);
loopForWrites();
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, close(transport_.get(), _));
}));
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, destroy(transport_.get()));
}));
transport_->close(folly::none);
@@ -869,25 +894,26 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
InSequence s;
Observer::Config config = {};
LegacyObserver::Config config = {};
config.packetsWrittenEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
const auto invokeForAllObservers =
[&cb1, &cb2, &cb3](const std::function<void(MockObserver&)>& fn) {
[&cb1, &cb2, &cb3](const std::function<void(MockLegacyObserver&)>& fn) {
fn(*cb1);
fn(*cb2);
fn(*cb3);
};
const auto invokeForEachObserverWithTestEvents =
[&cb1, &cb2](const std::function<void(MockObserver&)>& fn) {
[&cb1, &cb2](const std::function<void(MockLegacyObserver&)>& fn) {
fn(*cb1);
fn(*cb2);
};
// install observers
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, observerAttach(transport_.get()));
transport_->addObserver(&observer);
}));
@@ -903,21 +929,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
// matcher
const auto matcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(4)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(4)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(4)),
testing::Field(
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(4)),
testing::Field(
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(4000)));
invokeForEachObserverWithTestEvents(
([this, &matcher, oldTInfo = transport_->getTransportInfo()](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
.WillOnce(([oldTInfo](const auto& socket, const auto& event) {
EXPECT_EQ(
@@ -940,21 +970,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
// matcher
const auto matcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(5)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(1)),
testing::Field(
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(1000)));
invokeForEachObserverWithTestEvents(
([this, &matcher, oldTInfo = transport_->getTransportInfo()](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
.WillOnce(([oldTInfo](const auto& socket, const auto& event) {
EXPECT_EQ(
@@ -976,20 +1010,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
// matcher
const auto matcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(5)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(0)),
testing::Field(
&Observer::PacketsWrittenEvent::numBytesWritten, testing::Gt(0)));
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(0)));
invokeForEachObserverWithTestEvents(
([this, &matcher, oldTInfo = transport_->getTransportInfo()](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
.WillOnce(([oldTInfo](const auto& socket, const auto& event) {
EXPECT_EQ(
@@ -1015,21 +1054,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
// matcher
const auto matcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(6)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(6)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(1)),
testing::Field(
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(1000)));
invokeForEachObserverWithTestEvents(
([this, &matcher, oldTInfo = transport_->getTransportInfo()](
MockObserver& observer) {
MockLegacyObserver& observer) {
EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
.WillOnce(([oldTInfo](const auto& socket, const auto& event) {
EXPECT_EQ(
@@ -1051,10 +1094,10 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
loopForWrites();
}
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, close(transport_.get(), _));
}));
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, destroy(transport_.get()));
}));
transport_->close(folly::none);
@@ -1064,26 +1107,27 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
InSequence s;
Observer::Config config = {};
LegacyObserver::Config config = {};
config.packetsWrittenEvents = true;
config.appRateLimitedEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
const auto invokeForAllObservers =
[&cb1, &cb2, &cb3](const std::function<void(MockObserver&)>& fn) {
[&cb1, &cb2, &cb3](const std::function<void(MockLegacyObserver&)>& fn) {
fn(*cb1);
fn(*cb2);
fn(*cb3);
};
const auto invokeForEachObserverWithTestEvents =
[&cb1, &cb2](const std::function<void(MockObserver&)>& fn) {
[&cb1, &cb2](const std::function<void(MockLegacyObserver&)>& fn) {
fn(*cb1);
fn(*cb2);
};
// install observers
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, observerAttach(transport_.get()));
transport_->addObserver(&observer);
}));
@@ -1109,54 +1153,63 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
// matcher for event from startWritingFromAppLimited
const auto startWritingFromAppLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::IsEmpty()),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field(
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
// matcher for event from packetsWritten
const auto packetsWrittenMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(4)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check below
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(
upperBoundCurrentBytesWritable - bytesToWrite))),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(4)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(4)),
testing::Field(
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(4)),
testing::Field(
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(bytesToWrite)));
// matcher for event from appRateLimited
const auto appRateLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(4)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check below
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(
upperBoundCurrentBytesWritable - bytesToWrite))));
invokeForEachObserverWithTestEvents(
([this, &startWritingFromAppLimitedMatcher](MockObserver& observer) {
([this,
&startWritingFromAppLimitedMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
startWritingFromAppLimited(
@@ -1167,7 +1220,8 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
([this,
&packetsWrittenMatcher,
cwndInBytes,
oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
oldTInfo =
transport_->getTransportInfo()](MockLegacyObserver& observer) {
EXPECT_CALL(
observer, packetsWritten(transport_.get(), packetsWrittenMatcher))
.WillOnce(([cwndInBytes, oldTInfo](
@@ -1183,7 +1237,8 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
([this,
&appRateLimitedMatcher,
cwndInBytes,
oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
oldTInfo =
transport_->getTransportInfo()](MockLegacyObserver& observer) {
EXPECT_CALL(
observer, appRateLimited(transport_.get(), appRateLimitedMatcher))
.WillOnce(([cwndInBytes, oldTInfo](
@@ -1214,87 +1269,96 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
// matcher for event from startWritingFromAppLimited
const auto startWritingFromAppLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(4)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field(
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(
folly::Optional<uint64_t>(upperBoundCurrentBytesWritable))));
// matcher for event from packetsWritten
const auto packetsWrittenMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(5)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check below
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(
upperBoundCurrentBytesWritable - bytesToWrite))),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(1)),
testing::Field(
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(bytesToWrite)));
// matcher for event from appRateLimited
const auto appRateLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(5)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeNum)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check below
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(
upperBoundCurrentBytesWritable - bytesToWrite))));
invokeForEachObserverWithTestEvents(
([this, &startWritingFromAppLimitedMatcher](MockObserver& observer) {
([this,
&startWritingFromAppLimitedMatcher](MockLegacyObserver& observer) {
EXPECT_CALL(
observer,
startWritingFromAppLimited(
transport_.get(), startWritingFromAppLimitedMatcher));
}));
invokeForEachObserverWithTestEvents(
([this,
invokeForEachObserverWithTestEvents(([this,
&packetsWrittenMatcher,
oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
oldTInfo =
transport_->getTransportInfo()](
MockLegacyObserver& observer) {
EXPECT_CALL(
observer, packetsWritten(transport_.get(), packetsWrittenMatcher))
.WillOnce(([oldTInfo](const auto& socket, const auto& event) {
EXPECT_EQ(
oldTInfo.writableBytes -
(socket->getTransportInfo().bytesSent -
oldTInfo.bytesSent),
(socket->getTransportInfo().bytesSent - oldTInfo.bytesSent),
event.maybeWritableBytes);
}));
}));
invokeForEachObserverWithTestEvents(
([this,
invokeForEachObserverWithTestEvents(([this,
&appRateLimitedMatcher,
oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
oldTInfo =
transport_->getTransportInfo()](
MockLegacyObserver& observer) {
EXPECT_CALL(
observer, appRateLimited(transport_.get(), appRateLimitedMatcher))
.WillOnce(([oldTInfo](const auto& socket, const auto& event) {
EXPECT_EQ(
oldTInfo.writableBytes -
(socket->getTransportInfo().bytesSent -
oldTInfo.bytesSent),
(socket->getTransportInfo().bytesSent - oldTInfo.bytesSent),
event.maybeWritableBytes);
}));
}));
@@ -1311,10 +1375,10 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
writeNum++;
}
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, close(transport_.get(), _));
}));
invokeForAllObservers(([this](MockObserver& observer) {
invokeForAllObservers(([this](MockLegacyObserver& observer) {
EXPECT_CALL(observer, destroy(transport_.get()));
}));
transport_->close(folly::none);
@@ -1322,10 +1386,12 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
}
TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalLocalOpenClose) {
Observer::Config configWithStreamEvents = {};
LegacyObserver::Config configWithStreamEvents = {};
configWithStreamEvents.streamEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 =
std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
EXPECT_CALL(*cb1, observerAttach(transport_.get()));
transport_->addObserver(cb1.get());
EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1334,7 +1400,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalLocalOpenClose) {
transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
const auto id = 0x01;
const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
id, StreamInitiator::Local, StreamDirectionality::Bidirectional);
EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));
@@ -1363,10 +1429,12 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalLocalOpenClose) {
}
TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalRemoteOpenClose) {
Observer::Config configWithStreamEvents = {};
LegacyObserver::Config configWithStreamEvents = {};
configWithStreamEvents.streamEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 =
std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
EXPECT_CALL(*cb1, observerAttach(transport_.get()));
transport_->addObserver(cb1.get());
EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1375,7 +1443,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalRemoteOpenClose) {
transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
const auto id = 0x00;
const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
id, StreamInitiator::Remote, StreamDirectionality::Bidirectional);
EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));
@@ -1404,10 +1472,12 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalRemoteOpenClose) {
}
TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalLocalOpenClose) {
Observer::Config configWithStreamEvents = {};
LegacyObserver::Config configWithStreamEvents = {};
configWithStreamEvents.streamEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 =
std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
EXPECT_CALL(*cb1, observerAttach(transport_.get()));
transport_->addObserver(cb1.get());
EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1416,7 +1486,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalLocalOpenClose) {
transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
const auto id = 0x03;
const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
id, StreamInitiator::Local, StreamDirectionality::Unidirectional);
EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));
@@ -1445,10 +1515,12 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalLocalOpenClose) {
}
TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalRemoteOpenClose) {
Observer::Config configWithStreamEvents = {};
LegacyObserver::Config configWithStreamEvents = {};
configWithStreamEvents.streamEvents = true;
auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
auto cb1 =
std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
LegacyObserver::Config());
EXPECT_CALL(*cb1, observerAttach(transport_.get()));
transport_->addObserver(cb1.get());
EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1457,7 +1529,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalRemoteOpenClose) {
transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
const auto id = 0x02;
const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
id, StreamInitiator::Remote, StreamDirectionality::Unidirectional);
EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));

367
quic/api/test/QuicTypedTransportTest.cpp
View File

@@ -759,7 +759,7 @@ class QuicTypedTransportTestForObservers : public QuicTypedTransportTest<T> {
if constexpr (std::is_same_v<T, QuicClientTransportAfterStartTestBase>) {
return testing::Property(
&quic::Observer::AcksProcessedEvent::getAckEvents,
&quic::SocketObserverInterface::AcksProcessedEvent::getAckEvents,
testing::ElementsAre(testing::AllOf(
// ack time, adjusted ack time, RTT not supported for client now
testing::Field(
@@ -775,7 +775,7 @@ class QuicTypedTransportTestForObservers : public QuicTypedTransportTest<T> {
testing::SizeIs(expectedNumAckedPackets)))));
} else if constexpr (std::is_same_v<T, QuicServerTransportTestBase>) {
return testing::Property(
&quic::Observer::AcksProcessedEvent::getAckEvents,
&quic::SocketObserverInterface::AcksProcessedEvent::getAckEvents,
testing::ElementsAre(testing::AllOf(
testing::Field(&quic::AckEvent::ackTime, testing::Eq(ackTime)),
testing::Field(
@@ -823,12 +823,13 @@ class QuicTypedTransportTestForObservers : public QuicTypedTransportTest<T> {
const StreamDirectionality streamDirectionality) {
return testing::AllOf(
testing::Field(
&quic::Observer::StreamEvent::streamId, testing::Eq(streamId)),
&quic::SocketObserverInterface::StreamEvent::streamId,
testing::Eq(streamId)),
testing::Field(
&quic::Observer::StreamEvent::streamInitiator,
&quic::SocketObserverInterface::StreamEvent::streamInitiator,
testing::Eq(streamInitiator)),
testing::Field(
&quic::Observer::StreamEvent::streamDirectionality,
&quic::SocketObserverInterface::StreamEvent::streamDirectionality,
testing::Eq(streamDirectionality)));
}
};
@@ -840,7 +841,7 @@ TYPED_TEST_SUITE(
TYPED_TEST(QuicTypedTransportTestForObservers, Attach) {
auto transport = this->getTransport();
auto observer = std::make_unique<StrictMock<MockObserver>>();
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*observer, observerAttach(transport));
transport->addObserver(observer.get());
@@ -855,7 +856,7 @@ TYPED_TEST(
QuicTypedTransportTestForObservers,
CloseNoErrorThenDestroyTransport) {
auto transport = this->getTransport();
auto observer = std::make_unique<StrictMock<MockObserver>>();
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*observer, observerAttach(transport));
transport->addObserver(observer.get());
@@ -878,7 +879,7 @@ TYPED_TEST(
QuicTypedTransportTestForObservers,
CloseWithErrorThenDestroyTransport) {
auto transport = this->getTransport();
auto observer = std::make_unique<StrictMock<MockObserver>>();
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>();
EXPECT_CALL(*observer, observerAttach(transport));
transport->addObserver(observer.get());
@@ -898,15 +899,18 @@ TYPED_TEST(
}
TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsLocalOpenedStream) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -974,15 +978,18 @@ TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsLocalOpenedStream) {
TYPED_TEST(
QuicTypedTransportTestForObservers,
StreamEventsLocalOpenedStreamImmediateEofLocal) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1042,15 +1049,18 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
StreamEventsLocalOpenedStreamImmediateEofLocalRemote) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1105,15 +1115,18 @@ TYPED_TEST(
}
TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsPeerOpenedStream) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1175,15 +1188,18 @@ TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsPeerOpenedStream) {
TYPED_TEST(
QuicTypedTransportTestForObservers,
StreamEventsPeerOpenedStreamImmediateEofRemote) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1241,15 +1257,18 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
StreamEventsPeerOpenedStreamImmediateEofLocalRemote) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1301,15 +1320,18 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
StreamEventsPeerOpenedStreamStopSendingPlusRstTriggersRst) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1385,15 +1407,18 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
StreamEventsPeerOpenedStreamStopSendingPlusRstTriggersRstBytesInFlight) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1467,15 +1492,18 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
StreamEventsPeerOpenedStreamImmediateEorStopSendingTriggersRstBytesInFlight) {
MockObserver::Config configWithStreamEventsEnabled;
MockLegacyObserver::Config configWithStreamEventsEnabled;
configWithStreamEventsEnabled.streamEvents = true;
auto transport = this->getTransport();
auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoStreamEvents =
std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithStreamEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
auto observerWithStreamEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(
configWithStreamEventsEnabled);
EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
transport->addObserver(observerWithNoStreamEvents.get());
@@ -1560,16 +1588,16 @@ TYPED_TEST(
std::make_unique<StaticCwndCongestionController>(
StaticCwndCongestionController::CwndInBytes(cwndInBytes));
MockObserver::Config configWithEventsEnabled;
MockLegacyObserver::Config configWithEventsEnabled;
configWithEventsEnabled.appRateLimitedEvents = true;
configWithEventsEnabled.packetsWrittenEvents = true;
auto transport = this->getTransport();
auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
auto observerWithEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
transport->addObserver(observerWithNoEvents.get());
@@ -1599,14 +1627,16 @@ TYPED_TEST(
// matcher for event from startWritingFromAppLimited
const auto startWritingFromAppLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::IsEmpty()),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field(
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
EXPECT_CALL(*observerWithNoEvents, startWritingFromAppLimited(_, _))
.Times(0);
@@ -1622,22 +1652,26 @@ TYPED_TEST(
// matcher for event from packetsWritten
const auto packetsWrittenMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(1)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check in WillOnce()
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(cwndInBytes - strLength))),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(1)),
testing::Field( // precise check in WillOnce()
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(strLength)));
EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
EXPECT_CALL(
@@ -1668,14 +1702,16 @@ TYPED_TEST(
// matcher for event from appRateLimited
const auto appRateLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(1)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check below
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(cwndInBytes - strLength))));
EXPECT_CALL(*observerWithNoEvents, appRateLimited(_, _)).Times(0);
@@ -1736,16 +1772,16 @@ TYPED_TEST(
std::make_unique<StaticCwndCongestionController>(
StaticCwndCongestionController::CwndInBytes(cwndInBytes));
MockObserver::Config configWithEventsEnabled;
MockLegacyObserver::Config configWithEventsEnabled;
configWithEventsEnabled.appRateLimitedEvents = true;
configWithEventsEnabled.packetsWrittenEvents = true;
auto transport = this->getTransport();
auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
auto observerWithEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
transport->addObserver(observerWithNoEvents.get());
@@ -1777,14 +1813,16 @@ TYPED_TEST(
// matcher for event from startWritingFromAppLimited
const auto startWritingFromAppLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::IsEmpty()),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field(
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
EXPECT_CALL(*observerWithNoEvents, startWritingFromAppLimited(_, _))
.Times(0);
@@ -1800,22 +1838,26 @@ TYPED_TEST(
// matcher for event from packetsWritten
const auto packetsWrittenMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(1)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check in WillOnce()
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Eq(folly::Optional<uint64_t>(0))),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(1)),
testing::Field( // precise check in WillOnce(), expect overshoot CWND
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::AllOf(testing::Gt(bufLength), testing::Gt(cwndInBytes))));
EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
EXPECT_CALL(
@@ -1880,16 +1922,16 @@ TYPED_TEST(
std::make_unique<StaticCwndCongestionController>(
StaticCwndCongestionController::CwndInBytes(cwndInBytes));
MockObserver::Config configWithEventsEnabled;
MockLegacyObserver::Config configWithEventsEnabled;
configWithEventsEnabled.appRateLimitedEvents = true;
configWithEventsEnabled.packetsWrittenEvents = true;
auto transport = this->getTransport();
auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
auto observerWithEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
transport->addObserver(observerWithNoEvents.get());
@@ -1922,14 +1964,16 @@ TYPED_TEST(
// matcher for event from startWritingFromAppLimited
const auto startWritingFromAppLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::IsEmpty()),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field(
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
EXPECT_CALL(*observerWithNoEvents, startWritingFromAppLimited(_, _))
.Times(0);
@@ -1945,24 +1989,26 @@ TYPED_TEST(
// matcher for event from packetsWritten
const auto packetsWrittenMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets,
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(packetsExpectedWritten)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check in WillOnce()
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Eq(folly::Optional<uint64_t>(0))), // CWND exhausted
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(packetsExpectedWritten)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(packetsExpectedWritten)),
testing::Field( // precise check in WillOnce()
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Ge(cwndInBytes))); // full CWND written
EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
EXPECT_CALL(
@@ -2012,24 +2058,26 @@ TYPED_TEST(
// matcher for event from packetsWritten
const auto packetsWrittenMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets,
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(packetsExpectedWritten)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check in WillOnce()
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(packetsExpectedWritten)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(packetsExpectedWritten)),
testing::Field( // precise check in WillOnce()
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Lt(cwndInBytes)));
EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
EXPECT_CALL(
@@ -2060,15 +2108,16 @@ TYPED_TEST(
// matcher for event from appRateLimited
const auto appRateLimitedMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets,
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(packetsExpectedWritten)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
testing::Field( // precise check in WillOnce()
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Lt(folly::Optional<uint64_t>(cwndInBytes))));
EXPECT_CALL(*observerWithNoEvents, appRateLimited(_, _)).Times(0);
EXPECT_CALL(
@@ -2119,16 +2168,16 @@ TYPED_TEST(
// remove congestion controller
this->getNonConstConn().congestionController = nullptr;
MockObserver::Config configWithEventsEnabled;
MockLegacyObserver::Config configWithEventsEnabled;
configWithEventsEnabled.appRateLimitedEvents = true;
configWithEventsEnabled.packetsWrittenEvents = true;
auto transport = this->getTransport();
auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithEvents1 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
auto observerWithEvents2 =
std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
transport->addObserver(observerWithNoEvents.get());
@@ -2166,22 +2215,26 @@ TYPED_TEST(
// matcher for event from packetsWritten
const auto packetsWrittenMatcher = AllOf(
testing::Property(
&Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
&SocketObserverInterface::WriteEvent::getOutstandingPackets,
testing::SizeIs(1)),
testing::Field(
&Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
&SocketObserverInterface::WriteEvent::writeCount,
testing::Eq(writeCount)),
testing::Field(
&Observer::WriteEvent::maybeCwndInBytes,
&SocketObserverInterface::WriteEvent::maybeCwndInBytes,
testing::Eq(folly::Optional<uint64_t>(folly::none))),
testing::Field(
&Observer::WriteEvent::maybeWritableBytes,
&SocketObserverInterface::WriteEvent::maybeWritableBytes,
testing::Eq(folly::Optional<uint64_t>(folly::none))),
testing::Field(
&Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
&SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
testing::Eq(1)),
testing::Field(
&Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
&SocketObserverInterface::PacketsWrittenEvent::
numAckElicitingPacketsWritten,
testing::Eq(1)),
testing::Field( // precise check in WillOnce()
&Observer::PacketsWrittenEvent::numBytesWritten,
&SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
testing::Gt(strLength)));
EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
EXPECT_CALL(
@@ -2225,15 +2278,15 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsOutstandingPacketSentThenAckedNoAckDelay) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -2298,15 +2351,15 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsOutstandingPacketSentThenAckedWithAckDelay) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -2371,15 +2424,15 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsOutstandingPacketSentThenAckedWithAckDelayEqRtt) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -2430,7 +2483,8 @@ TYPED_TEST(
testing::AllOf(
matcher,
testing::Property(
&quic::Observer::AcksProcessedEvent::getAckEvents,
&quic::SocketObserverInterface::AcksProcessedEvent::
getAckEvents,
testing::ElementsAre(testing::AllOf(testing::Field(
&quic::AckEvent::rttSampleNoAckDelay,
testing::AnyOf(
@@ -2442,7 +2496,8 @@ TYPED_TEST(
testing::AllOf(
matcher,
testing::Property(
&quic::Observer::AcksProcessedEvent::getAckEvents,
&quic::SocketObserverInterface::AcksProcessedEvent::
getAckEvents,
testing::ElementsAre(testing::AllOf(testing::Field(
&quic::AckEvent::rttSampleNoAckDelay,
testing::AnyOf(
@@ -2466,15 +2521,15 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsOutstandingPacketSentThenAckedWithTooLargeAckDelay) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -2525,7 +2580,8 @@ TYPED_TEST(
testing::AllOf(
matcher,
testing::Property(
&quic::Observer::AcksProcessedEvent::getAckEvents,
&quic::SocketObserverInterface::AcksProcessedEvent::
getAckEvents,
testing::ElementsAre(testing::AllOf(testing::Field(
&quic::AckEvent::rttSampleNoAckDelay,
testing::Eq(folly::none))))))));
@@ -2536,7 +2592,8 @@ TYPED_TEST(
testing::AllOf(
matcher,
testing::Property(
&quic::Observer::AcksProcessedEvent::getAckEvents,
&quic::SocketObserverInterface::AcksProcessedEvent::
getAckEvents,
testing::ElementsAre(testing::AllOf(testing::Field(
&quic::AckEvent::rttSampleNoAckDelay,
testing::Eq(folly::none))))))));
@@ -2559,15 +2616,15 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsThreeOutstandingPacketsSentThenAllAckedAtOnce) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -2645,15 +2702,15 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsThreeOutstandingPacketsSentAndAckedSequentially) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -2797,15 +2854,15 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsThreeOutstandingPacketsSentThenAckedSequentially) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -2958,7 +3015,7 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsThreeOutstandingPacketsSentThenFirstLastAckedSequentiallyThenSecondAcked) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
// prevent packets from being marked as lost
@@ -2968,11 +3025,11 @@ TYPED_TEST(
this->getNonConstConn().transportSettings.timeReorderingThreshDivisor = 1;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());
@@ -3123,7 +3180,7 @@ TYPED_TEST(
TYPED_TEST(
QuicTypedTransportTestForObservers,
AckEventsThreeOutstandingPacketsSentThenFirstLastAckedAtOnceThenSecondAcked) {
MockObserver::Config configWithAcksEnabled;
MockLegacyObserver::Config configWithAcksEnabled;
configWithAcksEnabled.acksProcessedEvents = true;
// prevent packets from being marked as lost
@@ -3133,11 +3190,11 @@ TYPED_TEST(
this->getNonConstConn().transportSettings.timeReorderingThreshDivisor = 1;
auto transport = this->getTransport();
auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
auto observerWithAcks1 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
auto observerWithAcks2 =
std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
transport->addObserver(observerWithNoAcks.get());

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

@@ -15,7 +15,7 @@ using namespace std;
using namespace quic;
using namespace ::testing;
class MockObserver {
class MockObjectObserver {
public:
MOCK_METHOD(void, accessed, (const string&));
};
@@ -23,9 +23,9 @@ class MockObserver {
TEST(MonitoredObjectTest, TestObserverCalled) {
InSequence s;
string x = "abc";
MockObserver observer;
MockObjectObserver observer;
auto accessFn =
std::bind(&MockObserver::accessed, &observer, placeholders::_1);
std::bind(&MockObjectObserver::accessed, &observer, placeholders::_1);
MonitoredObject<string> mo(x, accessFn);
EXPECT_CALL(observer, accessed(x)).Times(1);
EXPECT_EQ(x, mo->c_str());

4
quic/d6d/QuicD6DStateFunctions.cpp
View File

@@ -26,7 +26,7 @@ static TimePoint reportUpperBound(QuicConnectionStateBase& conn) {
QUIC_STATS(conn.statsCallback, onConnectionPMTUUpperBoundDetected);
if (conn.observers->size() > 0) {
Observer::PMTUUpperBoundEvent upperBoundEvent(
SocketObserverInterface::PMTUUpperBoundEvent upperBoundEvent(
now,
std::chrono::duration_cast<std::chrono::microseconds>(
now - d6d.meta.timeLastNonSearchState),
@@ -58,7 +58,7 @@ static TimePoint reportBlackhole(
auto& d6d = conn.d6d;
const auto now = Clock::now();
if (conn.observers->size() > 0) {
Observer::PMTUBlackholeEvent blackholeEvent(
SocketObserverInterface::PMTUBlackholeEvent blackholeEvent(
now,
std::chrono::duration_cast<std::chrono::microseconds>(
now - d6d.meta.timeLastNonSearchState),

72
quic/d6d/test/QuicD6DStateFunctionsTest.cpp
View File

@@ -189,11 +189,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInBase) {
const uint16_t expectPMTU = 1400;
auto& d6d = conn.d6d;
auto now = Clock::now();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(mockObserver.get());
observers->emplace_back(observer.get());
conn.observers = observers;
d6d.state = D6DMachineState::BASE;
d6d.outstandingProbes = 1;
@@ -220,7 +220,7 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInBase) {
EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
.Times(1)
.WillOnce(Return(expectPMTU));
EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _)).Times(0);
EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _)).Times(0);
onD6DLastProbeAcked(conn);
for (auto& callback : conn.pendingCallbacks) {
callback(nullptr);
@@ -237,11 +237,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingOne) {
const uint16_t expectPMTU = 1400;
auto& d6d = conn.d6d;
auto now = Clock::now();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(mockObserver.get());
observers->emplace_back(observer.get());
conn.observers = observers;
d6d.state = D6DMachineState::SEARCHING;
d6d.outstandingProbes = 1;
@@ -269,7 +269,7 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingOne) {
EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
.Times(1)
.WillOnce(Return(expectPMTU));
EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _)).Times(0);
EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _)).Times(0);
onD6DLastProbeAcked(conn);
for (auto& callback : conn.pendingCallbacks) {
callback(nullptr);
@@ -286,11 +286,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingMax) {
const uint16_t oversize = 1500;
auto& d6d = conn.d6d;
auto now = Clock::now();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(mockObserver.get());
observers->emplace_back(observer.get());
conn.observers = observers;
d6d.state = D6DMachineState::SEARCHING;
d6d.outstandingProbes = 3;
@@ -319,16 +319,18 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingMax) {
EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
.Times(1)
.WillOnce(Return(oversize));
EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _))
EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _))
.Times(1)
.WillOnce(Invoke([&](QuicSocket* /* qSocket */,
const Observer::PMTUUpperBoundEvent& event) {
.WillOnce(Invoke(
[&](QuicSocket* /* qSocket */,
const SocketObserverInterface::PMTUUpperBoundEvent& event) {
EXPECT_LT(now, event.upperBoundTime);
EXPECT_LT(0us, event.timeSinceLastNonSearchState);
EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
EXPECT_EQ(1450, event.upperBoundPMTU);
EXPECT_EQ(10, event.cumulativeProbesSent);
EXPECT_EQ(ProbeSizeRaiserType::ConstantStep, event.probeSizeRaiserType);
EXPECT_EQ(
ProbeSizeRaiserType::ConstantStep, event.probeSizeRaiserType);
}));
onD6DLastProbeAcked(conn);
for (auto& callback : conn.pendingCallbacks) {
@@ -345,11 +347,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInError) {
QuicConnectionStateBase conn(QuicNodeType::Server);
auto& d6d = conn.d6d;
auto now = Clock::now();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(mockObserver.get());
observers->emplace_back(observer.get());
conn.observers = observers;
d6d.state = D6DMachineState::ERROR;
d6d.outstandingProbes = 3;
@@ -377,7 +379,7 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInError) {
EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
.Times(1)
.WillOnce(Return(1300)); // Won't be used
EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _)).Times(0);
EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _)).Times(0);
onD6DLastProbeAcked(conn);
for (auto& callback : conn.pendingCallbacks) {
callback(nullptr);
@@ -393,11 +395,11 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearching) {
QuicConnectionStateBase conn(QuicNodeType::Server);
auto& d6d = conn.d6d;
auto now = Clock::now();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(mockObserver.get());
observers->emplace_back(observer.get());
conn.observers = observers;
d6d.state = D6DMachineState::SEARCHING;
d6d.outstandingProbes = 2;
@@ -439,10 +441,11 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearching) {
std::chrono::microseconds(kDefaultD6DBlackholeDetectionWindow).count(),
1); // Threshold of 1 will cause window to be set to 0
EXPECT_CALL(*mockObserver, pmtuBlackholeDetected(_, _))
EXPECT_CALL(*observer, pmtuBlackholeDetected(_, _))
.Times(1)
.WillOnce(Invoke([&](QuicSocket* /* qSocket */,
const Observer::PMTUBlackholeEvent& event) {
.WillOnce(
Invoke([&](QuicSocket* /* qSocket */,
const SocketObserverInterface::PMTUBlackholeEvent& event) {
EXPECT_LE(d6d.meta.timeLastNonSearchState, event.blackholeTime);
EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
EXPECT_EQ(D6DMachineState::SEARCHING, event.currentState);
@@ -470,11 +473,11 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearchComplete) {
QuicConnectionStateBase conn(QuicNodeType::Server);
auto& d6d = conn.d6d;
auto now = Clock::now();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(mockObserver.get());
observers->emplace_back(observer.get());
conn.observers = observers;
d6d.state = D6DMachineState::SEARCH_COMPLETE;
conn.udpSendPacketLen = d6d.basePMTU + 20;
@@ -516,10 +519,11 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearchComplete) {
std::chrono::microseconds(kDefaultD6DBlackholeDetectionWindow).count(),
1); // Threshold of 1 will cause window to be set to 0
EXPECT_CALL(*mockObserver, pmtuBlackholeDetected(_, _))
EXPECT_CALL(*observer, pmtuBlackholeDetected(_, _))
.Times(1)
.WillOnce(Invoke([&](QuicSocket* /* qSocket */,
const Observer::PMTUBlackholeEvent& event) {
.WillOnce(
Invoke([&](QuicSocket* /* qSocket */,
const SocketObserverInterface::PMTUBlackholeEvent& event) {
EXPECT_EQ(d6d.meta.timeLastNonSearchState, event.blackholeTime);
EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
EXPECT_EQ(D6DMachineState::SEARCH_COMPLETE, event.currentState);
@@ -547,11 +551,11 @@ TEST_F(QuicD6DStateFunctionsTest, ReachMaxPMTU) {
QuicConnectionStateBase conn(QuicNodeType::Server);
auto& d6d = conn.d6d;
auto now = Clock::now();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(mockObserver.get());
observers->emplace_back(observer.get());
conn.observers = observers;
d6d.state = D6DMachineState::SEARCHING;
d6d.maxPMTU = 1452;

2
quic/loss/QuicLossFunctions.h
View File

@@ -213,7 +213,7 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
<< " delayUntilLost=" << delayUntilLost.count() << "us"
<< " " << conn;
CongestionController::LossEvent lossEvent(lossTime);
folly::Optional<Observer::LossEvent> observerLossEvent;
folly::Optional<SocketObserverInterface::LossEvent> observerLossEvent;
if (!conn.observers->empty()) {
observerLossEvent.emplace(lossTime);
}

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

@@ -165,7 +165,7 @@ class QuicLossFunctionsTest : public TestWithParam<PacketNumberSpace> {
PacketNum packetNum,
bool lossByReorder,
bool lossByTimeout) {
return MockObserver::getLossPacketMatcher(
return MockLegacyObserver::getLossPacketMatcher(
packetNum, lossByReorder, lossByTimeout);
}
};
@@ -2021,9 +2021,9 @@ TEST_F(QuicLossFunctionsTest, PersistentCongestionNoPTO) {
TEST_F(QuicLossFunctionsTest, TestReorderLossObserverCallback) {
auto observers = std::make_shared<ObserverVec>();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.lossEvents = true;
auto ib = MockObserver(config);
auto ib = MockLegacyObserver(config);
auto conn = createConn();
// Register 1 observer
observers->emplace_back(&ib);
@@ -2074,7 +2074,7 @@ TEST_F(QuicLossFunctionsTest, TestReorderLossObserverCallback) {
packetLossDetected(
nullptr,
Field(
&Observer::LossEvent::lostPackets,
&SocketObserverInterface::LossEvent::lostPackets,
UnorderedElementsAre(
getLossPacketMatcher(1, true, false),
getLossPacketMatcher(2, true, false),
@@ -2088,9 +2088,9 @@ TEST_F(QuicLossFunctionsTest, TestReorderLossObserverCallback) {
TEST_F(QuicLossFunctionsTest, TestTimeoutLossObserverCallback) {
auto observers = std::make_shared<ObserverVec>();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.lossEvents = true;
auto ib = MockObserver(config);
auto ib = MockLegacyObserver(config);
auto conn = createConn();
// Register 1 observer
observers->emplace_back(&ib);
@@ -2142,7 +2142,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeoutLossObserverCallback) {
packetLossDetected(
nullptr,
Field(
&Observer::LossEvent::lostPackets,
&SocketObserverInterface::LossEvent::lostPackets,
UnorderedElementsAre(
getLossPacketMatcher(1, false, true),
getLossPacketMatcher(2, false, true),
@@ -2160,9 +2160,9 @@ TEST_F(QuicLossFunctionsTest, TestTimeoutLossObserverCallback) {
TEST_F(QuicLossFunctionsTest, TestTimeoutAndReorderLossObserverCallback) {
auto observers = std::make_shared<ObserverVec>();
Observer::Config config = {};
LegacyObserver::Config config = {};
config.lossEvents = true;
auto ib = MockObserver(config);
auto ib = MockLegacyObserver(config);
auto conn = createConn();
// Register 1 observer
observers->emplace_back(&ib);
@@ -2216,7 +2216,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeoutAndReorderLossObserverCallback) {
packetLossDetected(
nullptr,
Field(
&Observer::LossEvent::lostPackets,
&SocketObserverInterface::LossEvent::lostPackets,
UnorderedElementsAre(
getLossPacketMatcher(1, true, true),
getLossPacketMatcher(2, true, true),

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

@@ -4189,20 +4189,20 @@ TEST_P(
}
TEST_P(QuicServerTransportHandshakeTest, TestD6DStartCallback) {
Observer::Config config = {};
LegacyObserver::Config config = {};
config.pmtuEvents = true;
auto mockObserver = std::make_unique<MockObserver>(config);
server->addObserver(mockObserver.get());
auto observer = std::make_unique<MockLegacyObserver>(config);
server->addObserver(observer.get());
// Set oneRttReader so that maybeStartD6DPriobing passes its check
auto codec = std::make_unique<QuicReadCodec>(QuicNodeType::Server);
codec->setOneRttReadCipher(createNoOpAead());
server->getNonConstConn().readCodec = std::move(codec);
// And the state too
server->getNonConstConn().d6d.state = D6DMachineState::BASE;
EXPECT_CALL(*mockObserver, pmtuProbingStarted(_)).Times(1);
EXPECT_CALL(*observer, pmtuProbingStarted(_)).Times(1);
// CHLO should be enough to trigger probing
recvClientHello();
server->removeObserver(mockObserver.get());
server->removeObserver(observer.get());
}
TEST_F(QuicUnencryptedServerTransportTest, DuplicateOneRttWriteCipher) {

4
quic/state/AckHandlers.cpp
View File

@@ -73,7 +73,7 @@ AckEvent processAckFrame(
uint64_t dsrPacketsAcked = 0;
folly::Optional<decltype(conn.lossState.lastAckedPacketSentTime)>
lastAckedPacketSentTime;
folly::Optional<Observer::SpuriousLossEvent> spuriousLossEvent;
folly::Optional<LegacyObserver::SpuriousLossEvent> spuriousLossEvent;
// Used for debug only.
const auto originalPacketCount = conn.outstandings.packetCount;
if (conn.observers->size() > 0) {
@@ -198,7 +198,7 @@ AckEvent processAckFrame(
ackReceiveTimeOrNow - rPacketIt->metadata.time);
if (rttSample != rttSample.zero()) {
// notify observers
const Observer::PacketRTT packetRTT(
const SocketObserverInterface::PacketRTT packetRTT(
ackReceiveTimeOrNow, rttSample, frame.ackDelay, *rPacketIt);
for (const auto& observer : *(conn.observers)) {
conn.pendingCallbacks.emplace_back(

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

@@ -2322,9 +2322,9 @@ TEST_P(AckHandlersTest, TestRTTPacketObserverCallback) {
conn.congestionController = std::move(mockCongestionController);
// Register 1 observer
Observer::Config config = {};
LegacyObserver::Config config = {};
config.rttSamples = true;
auto ib = MockObserver(config);
auto ib = MockLegacyObserver(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(&ib);
@@ -2420,11 +2420,16 @@ TEST_P(AckHandlersTest, TestRTTPacketObserverCallback) {
rttSampleGenerated(
nullptr,
AllOf(
Field(&Observer::PacketRTT::rcvTime, ackData.ackTime),
Field(&Observer::PacketRTT::rttSample, rttSample),
Field(&Observer::PacketRTT::ackDelay, ackData.ackDelay),
Field(
&Observer::PacketRTT::metadata,
&SocketObserverInterface::PacketRTT::rcvTime,
ackData.ackTime),
Field(
&SocketObserverInterface::PacketRTT::rttSample, rttSample),
Field(
&SocketObserverInterface::PacketRTT::ackDelay,
ackData.ackDelay),
Field(
&SocketObserverInterface::PacketRTT::metadata,
Field(
&quic::OutstandingPacketMetadata::inflightBytes,
ackData.endSeq + 1)))));
@@ -2442,10 +2447,10 @@ TEST_P(AckHandlersTest, TestSpuriousObserverReorder) {
conn.congestionController = std::move(mockCongestionController);
// Register 1 observer
Observer::Config config = {};
LegacyObserver::Config config = {};
config.spuriousLossEvents = true;
config.lossEvents = true;
auto ib = MockObserver(config);
auto ib = MockLegacyObserver(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(&ib);
@@ -2480,11 +2485,11 @@ TEST_P(AckHandlersTest, TestSpuriousObserverReorder) {
packetLossDetected(
nullptr,
Field(
&Observer::LossEvent::lostPackets,
&SocketObserverInterface::LossEvent::lostPackets,
UnorderedElementsAre(
MockObserver::getLossPacketMatcher(0, true, false),
MockObserver::getLossPacketMatcher(1, true, false),
MockObserver::getLossPacketMatcher(2, true, false)))))
MockLegacyObserver::getLossPacketMatcher(0, true, false),
MockLegacyObserver::getLossPacketMatcher(1, true, false),
MockLegacyObserver::getLossPacketMatcher(2, true, false)))))
.Times(1);
// Here we receive the spurious loss packets in a late ack
@@ -2510,11 +2515,11 @@ TEST_P(AckHandlersTest, TestSpuriousObserverReorder) {
spuriousLossDetected(
nullptr,
Field(
&Observer::SpuriousLossEvent::spuriousPackets,
&SocketObserverInterface::SpuriousLossEvent::spuriousPackets,
UnorderedElementsAre(
MockObserver::getLossPacketMatcher(0, true, false),
MockObserver::getLossPacketMatcher(1, true, false),
MockObserver::getLossPacketMatcher(2, true, false)))))
MockLegacyObserver::getLossPacketMatcher(0, true, false),
MockLegacyObserver::getLossPacketMatcher(1, true, false),
MockLegacyObserver::getLossPacketMatcher(2, true, false)))))
.Times(1);
for (auto& callback : conn.pendingCallbacks) {
@@ -2529,10 +2534,10 @@ TEST_P(AckHandlersTest, TestSpuriousObserverTimeout) {
conn.congestionController = std::move(mockCongestionController);
// Register 1 observer
Observer::Config config = {};
LegacyObserver::Config config = {};
config.spuriousLossEvents = true;
config.lossEvents = true;
auto ib = MockObserver(config);
auto ib = MockLegacyObserver(config);
auto observers = std::make_shared<ObserverVec>();
observers->emplace_back(&ib);
@@ -2567,13 +2572,13 @@ TEST_P(AckHandlersTest, TestSpuriousObserverTimeout) {
packetLossDetected(
nullptr,
Field(
&Observer::LossEvent::lostPackets,
&SocketObserverInterface::LossEvent::lostPackets,
UnorderedElementsAre(
MockObserver::getLossPacketMatcher(5, false, true),
MockObserver::getLossPacketMatcher(6, false, true),
MockObserver::getLossPacketMatcher(7, false, true),
MockObserver::getLossPacketMatcher(8, false, true),
MockObserver::getLossPacketMatcher(9, false, true)))))
MockLegacyObserver::getLossPacketMatcher(5, false, true),
MockLegacyObserver::getLossPacketMatcher(6, false, true),
MockLegacyObserver::getLossPacketMatcher(7, false, true),
MockLegacyObserver::getLossPacketMatcher(8, false, true),
MockLegacyObserver::getLossPacketMatcher(9, false, true)))))
.Times(1);
// Here we receive the spurious loss packets in a late ack
@@ -2599,13 +2604,13 @@ TEST_P(AckHandlersTest, TestSpuriousObserverTimeout) {
spuriousLossDetected(
nullptr,
Field(
&Observer::SpuriousLossEvent::spuriousPackets,
&SocketObserverInterface::SpuriousLossEvent::spuriousPackets,
UnorderedElementsAre(
MockObserver::getLossPacketMatcher(5, false, true),
MockObserver::getLossPacketMatcher(6, false, true),
MockObserver::getLossPacketMatcher(7, false, true),
MockObserver::getLossPacketMatcher(8, false, true),
MockObserver::getLossPacketMatcher(9, false, true)))))
MockLegacyObserver::getLossPacketMatcher(5, false, true),
MockLegacyObserver::getLossPacketMatcher(6, false, true),
MockLegacyObserver::getLossPacketMatcher(7, false, true),
MockLegacyObserver::getLossPacketMatcher(8, false, true),
MockLegacyObserver::getLossPacketMatcher(9, false, true)))))
.Times(1);
for (auto& callback : conn.pendingCallbacks) {

10
quic/tools/tperf/tperf.cpp
View File

@@ -139,12 +139,14 @@ ProbeSizeRaiserType parseRaiserType(uint32_t type) {
}
}
class TPerfObserver : public Observer {
class TPerfObserver : public LegacyObserver {
public:
TPerfObserver(const Observer::Config& config) : Observer(config) {}
explicit TPerfObserver(const LegacyObserver::Config& config)
: LegacyObserver(config) {}
void appRateLimited(
QuicSocket* /* socket */,
const quic::Observer::AppLimitedEvent& /* appLimitedEvent */) override {
const quic::SocketObserverInterface::
AppLimitedEvent& /* appLimitedEvent */) override {
if (FLAGS_log_app_rate_limited) {
LOG(INFO) << "appRateLimited detected";
}
@@ -200,7 +202,7 @@ class TPerfAcceptObserver : public AcceptObserver {
TPerfAcceptObserver() {
// Create an observer config, only enabling events we are interested in
// receiving.
Observer::Config config = {};
LegacyObserver::Config config = {};
config.appRateLimitedEvents = true;
config.pmtuEvents = true;
config.rttSamples = true;