diff --git a/quic/api/test/QuicPacketSchedulerTest.cpp b/quic/api/test/QuicPacketSchedulerTest.cpp
index ae3ae04c1..84825d4fb 100644
--- a/quic/api/test/QuicPacketSchedulerTest.cpp
+++ b/quic/api/test/QuicPacketSchedulerTest.cpp
@@ -474,7 +474,7 @@ TEST_F(QuicPacketSchedulerTest, DoNotCloneHandshake) {
 TEST_F(QuicPacketSchedulerTest, CloneSchedulerUseNormalSchedulerFirst) {
   QuicClientConnectionState conn(
       FizzClientQuicHandshakeContext::Builder().build());
-  MockFrameScheduler mockScheduler;
+  NiceMock<MockFrameScheduler> mockScheduler;
   CloningScheduler cloningScheduler(mockScheduler, conn, "Mocker", 0);
   ShortHeader header(
       ProtectionType::KeyPhaseOne,
@@ -743,7 +743,7 @@ TEST_F(QuicPacketSchedulerTest, StreamFrameSchedulerRoundRobin) {
   EXPECT_EQ(conn.schedulingState.nextScheduledStream, 4);
 
   // Should write frames for stream2, stream3, followed by stream1 again.
-  MockQuicPacketBuilder builder2;
+  NiceMock<MockQuicPacketBuilder> builder2;
   EXPECT_CALL(builder2, remainingSpaceInPkt()).WillRepeatedly(Return(4096));
   EXPECT_CALL(builder2, appendFrame(_)).WillRepeatedly(Invoke([&](auto f) {
     builder2.frames_.push_back(f);
@@ -818,7 +818,7 @@ TEST_F(QuicPacketSchedulerTest, StreamFrameSchedulerRoundRobinControl) {
   EXPECT_EQ(conn.schedulingState.nextScheduledControlStream, stream2);
 
   // Should write frames for stream2, stream4, followed by stream 3 then 1.
-  MockQuicPacketBuilder builder2;
+  NiceMock<MockQuicPacketBuilder> builder2;
   EXPECT_CALL(builder2, remainingSpaceInPkt()).WillRepeatedly(Return(4096));
   EXPECT_CALL(builder2, appendFrame(_)).WillRepeatedly(Invoke([&](auto f) {
     builder2.frames_.push_back(f);
@@ -872,7 +872,7 @@ TEST_F(QuicPacketSchedulerTest, StreamFrameSchedulerRemoveOne) {
   conn.flowControlState.peerAdvertisedMaxOffset = 100000;
   conn.flowControlState.peerAdvertisedInitialMaxStreamOffsetBidiRemote = 100000;
   StreamFrameScheduler scheduler(conn);
-  MockQuicPacketBuilder builder;
+  NiceMock<MockQuicPacketBuilder> builder;
   auto stream1 =
       conn.streamManager->createNextBidirectionalStream().value()->id;
   auto stream2 =
diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp
index 75eb0d8e2..c6f5b4392 100644
--- a/quic/api/test/QuicTransportBaseTest.cpp
+++ b/quic/api/test/QuicTransportBaseTest.cpp
@@ -373,7 +373,8 @@ class QuicTransportImplTest : public Test {
  public:
   void SetUp() override {
     evb = std::make_unique<folly::EventBase>();
-    auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(evb.get());
+    auto socket =
+        std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(evb.get());
     socketPtr = socket.get();
     transport = std::make_shared<TestQuicTransport>(
         evb.get(), std::move(socket), connCallback);
@@ -394,7 +395,7 @@ class QuicTransportImplTest : public Test {
 
  protected:
   std::unique_ptr<folly::EventBase> evb;
-  MockConnectionCallback connCallback;
+  NiceMock<MockConnectionCallback> connCallback;
   std::shared_ptr<TestQuicTransport> transport;
   folly::test::MockAsyncUDPSocket* socketPtr;
 };
@@ -448,9 +449,9 @@ TEST_F(QuicTransportImplTest, ReadCallbackDataAvailable) {
   auto stream2 = transport->createBidirectionalStream().value();
   StreamId stream3 = 0x6;
 
-  MockReadCallback readCb1;
-  MockReadCallback readCb2;
-  MockReadCallback readCb3;
+  NiceMock<MockReadCallback> readCb1;
+  NiceMock<MockReadCallback> readCb2;
+  NiceMock<MockReadCallback> readCb3;
 
   transport->setReadCallback(stream1, &readCb1);
   transport->setReadCallback(stream2, &readCb2);
@@ -493,8 +494,8 @@ TEST_F(QuicTransportImplTest, ReadCallbackDataAvailable) {
 TEST_F(QuicTransportImplTest, ReadCallbackChangeReadCallback) {
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockReadCallback readCb1;
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb1;
+  NiceMock<MockReadCallback> readCb2;
 
   EXPECT_TRUE(transport->setReadCallback(stream1, nullptr).hasError());
 
@@ -526,8 +527,8 @@ TEST_F(QuicTransportImplTest, ReadCallbackUnsetAll) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
 
-  MockReadCallback readCb1;
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb1;
+  NiceMock<MockReadCallback> readCb2;
 
   // Set the read callbacks, and then add data to the stream, and see that the
   // callbacks are, in fact, called.
@@ -566,8 +567,8 @@ TEST_F(QuicTransportImplTest, ReadCallbackUnsetAll) {
 TEST_F(QuicTransportImplTest, ReadCallbackPauseResume) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
-  MockReadCallback readCb1;
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb1;
+  NiceMock<MockReadCallback> readCb2;
 
   transport->setReadCallback(stream1, &readCb1);
   transport->setReadCallback(stream2, &readCb2);
@@ -611,7 +612,7 @@ TEST_F(QuicTransportImplTest, ReadCallbackNoCallbackSet) {
 }
 
 TEST_F(QuicTransportImplTest, ReadCallbackInvalidStream) {
-  MockReadCallback readCb1;
+  NiceMock<MockReadCallback> readCb1;
   StreamId invalidStream = 10;
   EXPECT_TRUE(transport->setReadCallback(invalidStream, &readCb1).hasError());
   transport.reset();
@@ -620,7 +621,7 @@ TEST_F(QuicTransportImplTest, ReadCallbackInvalidStream) {
 TEST_F(QuicTransportImplTest, ReadData) {
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockReadCallback readCb1;
+  NiceMock<MockReadCallback> readCb1;
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
 
   transport->setReadCallback(stream1, &readCb1);
@@ -654,7 +655,7 @@ TEST_F(QuicTransportImplTest, ReadData) {
 TEST_F(QuicTransportImplTest, UnidirectionalReadData) {
   auto stream1 = 0x6;
 
-  MockReadCallback readCb1;
+  NiceMock<MockReadCallback> readCb1;
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
 
   transport->addDataToStream(stream1, StreamBuffer(readData->clone(), 0));
@@ -686,7 +687,7 @@ TEST_F(QuicTransportImplTest, ReadDataUnsetReadCallbackInCallback) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
 
-  MockReadCallback readCb1;
+  NiceMock<MockReadCallback> readCb1;
   transport->setReadCallback(stream1, &readCb1);
 
   transport->addDataToStream(stream1, StreamBuffer(readData->clone(), 0, true));
@@ -721,7 +722,7 @@ TEST_F(QuicTransportImplTest, ReadCallbackForClientOutOfOrderStream) {
 
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
 
-  MockReadCallback streamRead;
+  NiceMock<MockReadCallback> streamRead;
 
   for (StreamId start = 0x00; start <= clientOutOfOrderStream;
        start += kStreamIncrement) {
@@ -770,7 +771,7 @@ TEST_F(QuicTransportImplTest, ReadDataInvalidStream) {
 TEST_F(QuicTransportImplTest, ReadError) {
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockReadCallback readCb1;
+  NiceMock<MockReadCallback> readCb1;
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
 
   transport->setReadCallback(stream1, &readCb1);
@@ -786,8 +787,8 @@ TEST_F(QuicTransportImplTest, ReadCallbackDeleteTransport) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
 
-  MockReadCallback readCb1;
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb1;
+  NiceMock<MockReadCallback> readCb2;
 
   transport->setReadCallback(stream1, &readCb1);
   transport->setReadCallback(stream2, &readCb2);
@@ -866,7 +867,7 @@ TEST_F(QuicTransportImplTest, onNewBidirectionalStreamSetReadCallback) {
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
   transport->addCryptoData(StreamBuffer(readData->clone(), 0, true));
 
-  MockReadCallback stream2Read;
+  NiceMock<MockReadCallback> stream2Read;
   StreamId stream2 = 0x00;
   EXPECT_CALL(connCallback, onNewBidirectionalStream(stream2))
       .WillOnce(Invoke(
@@ -874,7 +875,7 @@ TEST_F(QuicTransportImplTest, onNewBidirectionalStreamSetReadCallback) {
   transport->addDataToStream(stream2, StreamBuffer(readData->clone(), 0, true));
 
   StreamId stream3 = 0x10;
-  MockReadCallback streamRead;
+  NiceMock<MockReadCallback> streamRead;
   for (StreamId start = stream2 + kStreamIncrement; start <= stream3;
        start += kStreamIncrement) {
     EXPECT_CALL(connCallback, onNewBidirectionalStream(start))
@@ -1043,7 +1044,7 @@ TEST_F(QuicTransportImplTest, CloseStreamAfterReadError) {
   transport->transportConn->qLogger = qLogger;
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockReadCallback readCb1;
+  NiceMock<MockReadCallback> readCb1;
   transport->setReadCallback(stream1, &readCb1);
 
   transport->addStreamReadError(stream1, LocalErrorCode::NO_ERROR);
@@ -1065,7 +1066,7 @@ TEST_F(QuicTransportImplTest, CloseStreamAfterReadError) {
 
 TEST_F(QuicTransportImplTest, CloseStreamAfterReadFin) {
   auto stream2 = transport->createBidirectionalStream().value();
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb2;
   transport->setReadCallback(stream2, &readCb2);
 
   transport->addDataToStream(
@@ -1083,7 +1084,8 @@ TEST_F(QuicTransportImplTest, CloseStreamAfterReadFin) {
 }
 
 TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksDeque) {
-  MockDeliveryCallback mockedDeliveryCallback1, mockedDeliveryCallback2;
+  NiceMock<MockDeliveryCallback> mockedDeliveryCallback1,
+      mockedDeliveryCallback2;
   std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>> callbacks;
   callbacks.emplace_back(0, &mockedDeliveryCallback1);
   callbacks.emplace_back(100, &mockedDeliveryCallback2);
@@ -1094,7 +1096,8 @@ TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksDeque) {
 }
 
 TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksMap) {
-  MockDeliveryCallback mockedDeliveryCallback1, mockedDeliveryCallback2;
+  NiceMock<MockDeliveryCallback> mockedDeliveryCallback1,
+      mockedDeliveryCallback2;
   folly::F14FastMap<
       StreamId,
       std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>>
@@ -1115,8 +1118,8 @@ TEST_F(QuicTransportImplTest, CloseTransportCleansupOutstandingCounters) {
 TEST_F(QuicTransportImplTest, DeliveryCallbackUnsetAll) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
-  MockDeliveryCallback dcb1;
-  MockDeliveryCallback dcb2;
+  NiceMock<MockDeliveryCallback> dcb1;
+  NiceMock<MockDeliveryCallback> dcb2;
 
   transport->registerDeliveryCallback(stream1, 10, &dcb1);
   transport->registerDeliveryCallback(stream2, 20, &dcb2);
@@ -1135,8 +1138,8 @@ TEST_F(QuicTransportImplTest, DeliveryCallbackUnsetAll) {
 TEST_F(QuicTransportImplTest, DeliveryCallbackUnsetOne) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
-  MockDeliveryCallback dcb1;
-  MockDeliveryCallback dcb2;
+  NiceMock<MockDeliveryCallback> dcb1;
+  NiceMock<MockDeliveryCallback> dcb2;
 
   transport->registerDeliveryCallback(stream1, 10, &dcb1);
   transport->registerDeliveryCallback(stream2, 20, &dcb2);
@@ -1157,8 +1160,8 @@ TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpire) {
 
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
-  MockDeliveryCallback dcb1;
-  MockDeliveryCallback dcb2;
+  NiceMock<MockDeliveryCallback> dcb1;
+  NiceMock<MockDeliveryCallback> dcb2;
 
   transport->registerDeliveryCallback(stream1, 10, &dcb1);
   transport->registerDeliveryCallback(stream2, 20, &dcb2);
@@ -1183,8 +1186,8 @@ TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpireCallbacksLeft) {
 
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
-  MockDeliveryCallback dcb1;
-  MockDeliveryCallback dcb2;
+  NiceMock<MockDeliveryCallback> dcb1;
+  NiceMock<MockDeliveryCallback> dcb2;
 
   transport->registerDeliveryCallback(stream1, 10, &dcb1);
   transport->registerDeliveryCallback(stream1, 20, &dcb1);
@@ -1206,9 +1209,9 @@ TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpireCallbacksLeft) {
 
 TEST_F(QuicTransportImplTest, RegisterDeliveryCallbackLowerThanExpected) {
   auto stream = transport->createBidirectionalStream().value();
-  MockDeliveryCallback dcb1;
-  MockDeliveryCallback dcb2;
-  MockDeliveryCallback dcb3;
+  NiceMock<MockDeliveryCallback> dcb1;
+  NiceMock<MockDeliveryCallback> dcb2;
+  NiceMock<MockDeliveryCallback> dcb3;
 
   transport->registerDeliveryCallback(stream, 10, &dcb1);
   transport->registerDeliveryCallback(stream, 20, &dcb2);
@@ -1228,7 +1231,7 @@ TEST_F(QuicTransportImplTest, RegisterDeliveryCallbackLowerThanExpected) {
 
 TEST_F(QuicTransportImplTest, RegisterDeliveryCallbackLowerThanExpectedClose) {
   auto stream = transport->createBidirectionalStream().value();
-  MockDeliveryCallback dcb;
+  NiceMock<MockDeliveryCallback> dcb;
   auto streamState = transport->transportConn->streamManager->getStream(stream);
   streamState->currentWriteOffset = 7;
 
@@ -1239,7 +1242,7 @@ TEST_F(QuicTransportImplTest, RegisterDeliveryCallbackLowerThanExpectedClose) {
 }
 
 TEST_F(QuicTransportImplTest, TestNotifyPendingConnWriteOnCloseWithoutError) {
-  MockWriteCallback wcb;
+  NiceMock<MockWriteCallback> wcb;
   EXPECT_CALL(wcb, onConnectionWriteError(IsError(LocalErrorCode::NO_ERROR)));
   transport->notifyPendingWriteOnConnection(&wcb);
   transport->close(folly::none);
@@ -1247,7 +1250,7 @@ TEST_F(QuicTransportImplTest, TestNotifyPendingConnWriteOnCloseWithoutError) {
 }
 
 TEST_P(QuicTransportImplTestClose, TestNotifyPendingConnWriteOnCloseWithError) {
-  MockWriteCallback wcb;
+  NiceMock<MockWriteCallback> wcb;
   transport->notifyPendingWriteOnConnection(&wcb);
   if (GetParam()) {
     EXPECT_CALL(
@@ -1265,7 +1268,7 @@ TEST_P(QuicTransportImplTestClose, TestNotifyPendingConnWriteOnCloseWithError) {
 
 TEST_F(QuicTransportImplTest, TestNotifyPendingWriteWithActiveCallback) {
   auto stream = transport->createBidirectionalStream().value();
-  MockWriteCallback wcb;
+  NiceMock<MockWriteCallback> wcb;
   EXPECT_CALL(wcb, onStreamWriteReady(stream, _));
   auto ok1 = transport->notifyPendingWriteOnStream(stream, &wcb);
   EXPECT_TRUE(ok1.hasValue());
@@ -1276,7 +1279,7 @@ TEST_F(QuicTransportImplTest, TestNotifyPendingWriteWithActiveCallback) {
 
 TEST_F(QuicTransportImplTest, TestNotifyPendingWriteOnCloseWithoutError) {
   auto stream = transport->createBidirectionalStream().value();
-  MockWriteCallback wcb;
+  NiceMock<MockWriteCallback> wcb;
   EXPECT_CALL(
       wcb, onStreamWriteError(stream, IsError(LocalErrorCode::NO_ERROR)));
   transport->notifyPendingWriteOnStream(stream, &wcb);
@@ -1286,7 +1289,7 @@ TEST_F(QuicTransportImplTest, TestNotifyPendingWriteOnCloseWithoutError) {
 
 TEST_P(QuicTransportImplTestClose, TestNotifyPendingWriteOnCloseWithError) {
   auto stream = transport->createBidirectionalStream().value();
-  MockWriteCallback wcb;
+  NiceMock<MockWriteCallback> wcb;
   transport->notifyPendingWriteOnStream(stream, &wcb);
   if (GetParam()) {
     EXPECT_CALL(
@@ -1314,10 +1317,10 @@ TEST_F(QuicTransportImplTest, TestGracefulCloseWithActiveStream) {
   EXPECT_CALL(connCallback, onConnectionError(_)).Times(0);
 
   auto stream = transport->createBidirectionalStream().value();
-  MockWriteCallback wcb;
-  MockWriteCallback wcbConn;
-  MockReadCallback rcb;
-  MockDeliveryCallback deliveryCb;
+  NiceMock<MockWriteCallback> wcb;
+  NiceMock<MockWriteCallback> wcbConn;
+  NiceMock<MockReadCallback> rcb;
+  NiceMock<MockDeliveryCallback> deliveryCb;
   EXPECT_CALL(
       wcb, onStreamWriteError(stream, IsError(LocalErrorCode::NO_ERROR)));
   EXPECT_CALL(
@@ -1362,10 +1365,10 @@ TEST_F(QuicTransportImplTest, TestGracefulCloseWithActiveStream) {
 
 TEST_F(QuicTransportImplTest, TestGracefulCloseWithNoActiveStream) {
   auto stream = transport->createBidirectionalStream().value();
-  MockWriteCallback wcb;
-  MockWriteCallback wcbConn;
-  MockReadCallback rcb;
-  MockDeliveryCallback deliveryCb;
+  NiceMock<MockWriteCallback> wcb;
+  NiceMock<MockWriteCallback> wcbConn;
+  NiceMock<MockReadCallback> rcb;
+  NiceMock<MockDeliveryCallback> deliveryCb;
   EXPECT_CALL(rcb, readError(stream, IsError(LocalErrorCode::NO_ERROR)));
   EXPECT_CALL(deliveryCb, onDeliveryAck(stream, _, _));
 
@@ -1401,10 +1404,10 @@ TEST_F(QuicTransportImplTest, TestGracefulCloseWithNoActiveStream) {
 
 TEST_F(QuicTransportImplTest, TestImmediateClose) {
   auto stream = transport->createBidirectionalStream().value();
-  MockWriteCallback wcb;
-  MockWriteCallback wcbConn;
-  MockReadCallback rcb;
-  MockDeliveryCallback deliveryCb;
+  NiceMock<MockWriteCallback> wcb;
+  NiceMock<MockWriteCallback> wcbConn;
+  NiceMock<MockReadCallback> rcb;
+  NiceMock<MockDeliveryCallback> deliveryCb;
   EXPECT_CALL(
       wcb,
       onStreamWriteError(
@@ -1536,7 +1539,8 @@ INSTANTIATE_TEST_CASE_P(
 
 TEST_P(QuicTransportImplTestUniBidi, AppIdleTest) {
   auto& conn = transport->getConnectionState();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
 
@@ -1549,7 +1553,8 @@ TEST_P(QuicTransportImplTestUniBidi, AppIdleTest) {
 
 TEST_P(QuicTransportImplTestUniBidi, AppIdleTestControlStreams) {
   auto& conn = transport->getConnectionState();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
 
@@ -1570,7 +1575,8 @@ TEST_P(QuicTransportImplTestUniBidi, AppIdleTestControlStreams) {
 
 TEST_P(QuicTransportImplTestUniBidi, AppIdleTestOnlyControlStreams) {
   auto& conn = transport->getConnectionState();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
 
@@ -1660,8 +1666,8 @@ TEST_F(QuicTransportImplTest, PeekCallbackDataAvailable) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
 
-  MockPeekCallback peekCb1;
-  MockPeekCallback peekCb2;
+  NiceMock<MockPeekCallback> peekCb1;
+  NiceMock<MockPeekCallback> peekCb2;
 
   transport->setPeekCallback(stream1, &peekCb1);
   transport->setPeekCallback(stream2, &peekCb2);
@@ -1703,8 +1709,8 @@ TEST_F(QuicTransportImplTest, PeekCallbackUnsetAll) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
 
-  MockPeekCallback peekCb1;
-  MockPeekCallback peekCb2;
+  NiceMock<MockPeekCallback> peekCb1;
+  NiceMock<MockPeekCallback> peekCb2;
 
   // Set the peek callbacks and add data to the streams, and see that the
   // callbacks do indeed fire
@@ -1743,8 +1749,8 @@ TEST_F(QuicTransportImplTest, PeekCallbackChangePeekCallback) {
 
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockPeekCallback peekCb1;
-  MockPeekCallback peekCb2;
+  NiceMock<MockPeekCallback> peekCb1;
+  NiceMock<MockPeekCallback> peekCb2;
 
   transport->setPeekCallback(stream1, &peekCb1);
 
@@ -1767,7 +1773,7 @@ TEST_F(QuicTransportImplTest, PeekCallbackPauseResume) {
   InSequence enforceOrder;
 
   auto stream1 = transport->createBidirectionalStream().value();
-  MockPeekCallback peekCb1;
+  NiceMock<MockPeekCallback> peekCb1;
 
   transport->setPeekCallback(stream1, &peekCb1);
 
@@ -1805,7 +1811,7 @@ TEST_F(QuicTransportImplTest, PeekCallbackNoCallbackSet) {
 }
 
 TEST_F(QuicTransportImplTest, PeekCallbackInvalidStream) {
-  MockPeekCallback peekCb1;
+  NiceMock<MockPeekCallback> peekCb1;
   StreamId invalidStream = 10;
   EXPECT_TRUE(transport->setPeekCallback(invalidStream, &peekCb1).hasError());
   transport.reset();
@@ -1816,7 +1822,7 @@ TEST_F(QuicTransportImplTest, PeekData) {
 
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockPeekCallback peekCb1;
+  NiceMock<MockPeekCallback> peekCb1;
   auto peekData = folly::IOBuf::copyBuffer("actual stream data");
 
   transport->setPeekCallback(stream1, &peekCb1);
@@ -1899,8 +1905,8 @@ TEST_F(QuicTransportImplTest, PeekConsumeReadTest) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
 
-  MockPeekCallback peekCb;
-  MockReadCallback readCb;
+  NiceMock<MockPeekCallback> peekCb;
+  NiceMock<MockReadCallback> readCb;
 
   transport->setPeekCallback(stream1, &peekCb);
   transport->setReadCallback(stream1, &readCb);
@@ -2077,9 +2083,9 @@ TEST_F(QuicTransportImplTest, DataExpiredCallbackDataAvailable) {
   auto stream2 = transport->createBidirectionalStream().value();
   StreamId stream3 = 0x6;
 
-  MockDataExpiredCallback dataExpiredCb1;
-  MockDataExpiredCallback dataExpiredCb2;
-  MockDataExpiredCallback dataExpiredCb3;
+  NiceMock<MockDataExpiredCallback> dataExpiredCb1;
+  NiceMock<MockDataExpiredCallback> dataExpiredCb2;
+  NiceMock<MockDataExpiredCallback> dataExpiredCb3;
 
   transport->setDataExpiredCallback(stream1, &dataExpiredCb1);
   transport->setDataExpiredCallback(stream2, &dataExpiredCb2);
@@ -2104,8 +2110,8 @@ TEST_F(QuicTransportImplTest, DataExpiredCallbackDataAvailableWithDataRead) {
 
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockDataExpiredCallback dataExpiredCb1;
-  MockReadCallback readCb1;
+  NiceMock<MockDataExpiredCallback> dataExpiredCb1;
+  NiceMock<MockReadCallback> readCb1;
 
   transport->setDataExpiredCallback(stream1, &dataExpiredCb1);
   transport->setReadCallback(stream1, &readCb1);
@@ -2157,7 +2163,7 @@ TEST_F(
 
   TestDataExpiredCallback peekExecCb =
       TestDataExpiredCallback(*transport, stream1);
-  MockReadCallback readCb1;
+  NiceMock<MockReadCallback> readCb1;
 
   transport->setDataExpiredCallback(stream1, &peekExecCb);
   transport->setReadCallback(stream1, &readCb1);
@@ -2181,8 +2187,8 @@ TEST_F(QuicTransportImplTest, DataExpiredCallbackChangeCallback) {
 
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockDataExpiredCallback dataExpiredCb1;
-  MockDataExpiredCallback dataExpiredCb2;
+  NiceMock<MockDataExpiredCallback> dataExpiredCb1;
+  NiceMock<MockDataExpiredCallback> dataExpiredCb2;
 
   transport->setDataExpiredCallback(stream1, &dataExpiredCb1);
   EXPECT_CALL(dataExpiredCb1, onDataExpired(stream1, 5));
@@ -2214,7 +2220,7 @@ TEST_F(QuicTransportImplTest, DataExpiredCallbackNoCallbackSet) {
 TEST_F(QuicTransportImplTest, DataExpiredCallbackInvalidStream) {
   transport->transportConn->partialReliabilityEnabled = true;
 
-  MockDataExpiredCallback dataExpiredCb1;
+  NiceMock<MockDataExpiredCallback> dataExpiredCb1;
   StreamId invalidStream = 10;
   EXPECT_TRUE(transport->setDataExpiredCallback(invalidStream, &dataExpiredCb1)
                   .hasError());
@@ -2270,9 +2276,9 @@ TEST_F(QuicTransportImplTest, DataRejecteddCallbackDataAvailable) {
   auto stream2 = transport->createBidirectionalStream().value();
   StreamId stream3 = 0x6;
 
-  MockDataRejectedCallback dataRejectedCb1;
-  MockDataRejectedCallback dataRejectedCb2;
-  MockDataRejectedCallback dataRejectedCb3;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb1;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb2;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb3;
 
   transport->setDataRejectedCallback(stream1, &dataRejectedCb1);
   transport->setDataRejectedCallback(stream2, &dataRejectedCb2);
@@ -2297,10 +2303,10 @@ TEST_F(QuicTransportImplTest, DataRejecteddCallbackWithDeliveryCallbacks) {
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
 
-  MockDeliveryCallback dcb1;
-  MockDeliveryCallback dcb2;
-  MockDataRejectedCallback dataRejectedCb1;
-  MockDataRejectedCallback dataRejectedCb2;
+  NiceMock<MockDeliveryCallback> dcb1;
+  NiceMock<MockDeliveryCallback> dcb2;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb1;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb2;
 
   transport->registerDeliveryCallback(stream1, 10, &dcb1);
   transport->registerDeliveryCallback(stream2, 20, &dcb2);
@@ -2341,10 +2347,10 @@ TEST_F(
   auto stream1 = transport->createBidirectionalStream().value();
   auto stream2 = transport->createBidirectionalStream().value();
 
-  MockDeliveryCallback dcb1;
-  MockDeliveryCallback dcb2;
-  MockDataRejectedCallback dataRejectedCb1;
-  MockDataRejectedCallback dataRejectedCb2;
+  NiceMock<MockDeliveryCallback> dcb1;
+  NiceMock<MockDeliveryCallback> dcb2;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb1;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb2;
 
   transport->registerDeliveryCallback(stream1, 10, &dcb1);
   transport->registerDeliveryCallback(stream1, 25, &dcb1);
@@ -2384,8 +2390,8 @@ TEST_F(QuicTransportImplTest, DataRejectedCallbackChangeCallback) {
 
   auto stream1 = transport->createBidirectionalStream().value();
 
-  MockDataRejectedCallback dataRejectedCb1;
-  MockDataRejectedCallback dataRejectedCb2;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb1;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb2;
 
   transport->setDataRejectedCallback(stream1, &dataRejectedCb1);
   EXPECT_CALL(dataRejectedCb1, onDataRejected(stream1, 5));
@@ -2417,7 +2423,7 @@ TEST_F(QuicTransportImplTest, DataRejectedCallbackNoCallbackSet) {
 TEST_F(QuicTransportImplTest, DataRejectedCallbackInvalidStream) {
   transport->transportConn->partialReliabilityEnabled = true;
 
-  MockDataRejectedCallback dataRejectedCb1;
+  NiceMock<MockDataRejectedCallback> dataRejectedCb1;
   StreamId invalidStream = 10;
   EXPECT_TRUE(
       transport->setDataRejectedCallback(invalidStream, &dataRejectedCb1)
@@ -2455,9 +2461,9 @@ TEST_F(QuicTransportImplTest, SendDataRejected) {
 TEST_F(QuicTransportImplTest, CloseFromCancelDeliveryCallbacksForStream) {
   auto stream1 = *transport->createBidirectionalStream();
   auto stream2 = *transport->createBidirectionalStream();
-  MockDeliveryCallback deliveryCallback1;
-  MockDeliveryCallback deliveryCallback2;
-  MockDeliveryCallback deliveryCallback3;
+  NiceMock<MockDeliveryCallback> deliveryCallback1;
+  NiceMock<MockDeliveryCallback> deliveryCallback2;
+  NiceMock<MockDeliveryCallback> deliveryCallback3;
 
   transport->registerDeliveryCallback(stream1, 10, &deliveryCallback1);
   transport->registerDeliveryCallback(stream1, 20, &deliveryCallback2);
diff --git a/quic/api/test/QuicTransportFunctionsTest.cpp b/quic/api/test/QuicTransportFunctionsTest.cpp
index a8e37f6ce..c476503b5 100644
--- a/quic/api/test/QuicTransportFunctionsTest.cpp
+++ b/quic/api/test/QuicTransportFunctionsTest.cpp
@@ -142,7 +142,7 @@ class QuicTransportFunctionsTest : public Test {
   void SetUp() override {
     aead = test::createNoOpAead();
     headerCipher = test::createNoOpHeaderCipher();
-    transportInfoCb_ = std::make_unique<MockQuicStats>();
+    transportInfoCb_ = std::make_unique<NiceMock<MockQuicStats>>();
   }
 
   std::unique_ptr<QuicServerConnectionState> createConn() {
@@ -179,7 +179,8 @@ class QuicTransportFunctionsTest : public Test {
 
 TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
@@ -754,10 +755,11 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
   auto conn = createConn();
   conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
   auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
-  auto mockPacer = std::make_unique<MockPacer>();
+  auto mockPacer = std::make_unique<NiceMock<MockPacer>>();
   auto rawPacer = mockPacer.get();
   conn->pacer = std::move(mockPacer);
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   ASSERT_EQ(0, conn->lossState.totalBytesAcked);
@@ -846,7 +848,8 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithBytesStats) {
 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) {
   auto conn = createConn();
   conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   ShortHeader shortHeader(
@@ -968,12 +971,14 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) {
 
 TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketWithCC) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
@@ -1007,12 +1012,13 @@ TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketWithCC) {
 
 TEST_F(QuicTransportFunctionsTest, WriteQuicdataToSocketWithPacer) {
   auto conn = createConn();
-  auto mockPacer = std::make_unique<MockPacer>();
+  auto mockPacer = std::make_unique<NiceMock<MockPacer>>();
   auto rawPacer = mockPacer.get();
   conn->pacer = std::move(mockPacer);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
@@ -1035,13 +1041,15 @@ TEST_F(QuicTransportFunctionsTest, WriteQuicdataToSocketWithPacer) {
 
 TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketLimitTest) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   conn->udpSendPacketLen = aead->getCipherOverhead() + 50;
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
   // ~50 bytes
@@ -1131,12 +1139,14 @@ TEST_F(
     WriteQuicDataToSocketWhenInFlightBytesAreLimited) {
   auto conn = createConn();
   conn->oneRttWriteCipher = test::createNoOpAead();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
@@ -1174,12 +1184,14 @@ TEST_F(
 
 TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketWithNoBytesForHeader) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
@@ -1204,7 +1216,7 @@ TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketWithNoBytesForHeader) {
 
 TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketRetxBufferSorted) {
   EventBase evb;
-  folly::test::MockAsyncUDPSocket socket(&evb);
+  NiceMock<folly::test::MockAsyncUDPSocket> socket(&evb);
   auto conn = createConn();
   auto stream = conn->streamManager->createNextBidirectionalStream().value();
   auto buf1 = IOBuf::copyBuffer("Whatsapp");
@@ -1236,12 +1248,14 @@ TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketRetxBufferSorted) {
 
 TEST_F(QuicTransportFunctionsTest, NothingWritten) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   // 18 isn't enough to write 3 ack blocks, but is enough to write a pure
@@ -1283,7 +1297,8 @@ const QuicWriteFrame& getFirstFrameInOutstandingPackets(
 TEST_F(QuicTransportFunctionsTest, WriteBlockedFrameWhenBlocked) {
   auto conn = createConn();
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
   auto buf = buildRandomInputData(200);
@@ -1342,11 +1357,13 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingNewData) {
   // writeProbingDataToSocketForTest writes ShortHeader, thus it writes at
   // AppTraffic level
   auto currentPacketSeqNum = conn->ackStates.appDataAckState.nextPacketNum;
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
   auto buf = buildRandomInputData(conn->udpSendPacketLen * 2);
@@ -1374,7 +1391,8 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingOldData) {
   auto conn = createConn();
   conn->congestionController.reset();
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   EXPECT_CALL(*rawSocket, write(_, _)).WillRepeatedly(Return(100));
   auto capturingAead = std::make_unique<MockAead>();
@@ -1424,11 +1442,13 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingCryptoData) {
   // writes at Initial level.
   auto currentPacketSeqNum = conn.ackStates.initialAckState.nextPacketNum;
   // Replace real congestionController with MockCongestionController:
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   auto cryptoStream = &conn.cryptoState->initialStream;
   auto buf = buildRandomInputData(conn.udpSendPacketLen * 2);
@@ -1457,11 +1477,13 @@ TEST_F(QuicTransportFunctionsTest, WriteProbesNoNewDataNoCryptoDataNoOldData) {
   // writeProbingDataToSocketForTest uses ShortHeader, thus it writes at
   // AppTraffic level
   auto currentPacketSeqNum = conn->ackStates.appDataAckState.nextPacketNum;
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
   auto buf = buildRandomInputData(0);
@@ -1493,11 +1515,13 @@ TEST_F(QuicTransportFunctionsTest, ProbingNotWriteOtherFrames) {
   // writeProbingDataToSocketForTest uses ShortHeader, thus it writes at
   // AppTraffic level
   auto currentPacketSeqNum = conn->ackStates.appDataAckState.nextPacketNum;
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
   RstStreamFrame rstFrame(stream1->id, GenericApplicationErrorCode::UNKNOWN, 0);
@@ -1549,7 +1573,8 @@ TEST_F(QuicTransportFunctionsTest, TestCryptoWritingIsHandshakeInOutstanding) {
   auto buf = buildRandomInputData(200);
   writeDataToQuicStream(*cryptoStream, buf->clone());
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
   EXPECT_EQ(
       1,
@@ -1570,12 +1595,14 @@ TEST_F(QuicTransportFunctionsTest, TestCryptoWritingIsHandshakeInOutstanding) {
 
 TEST_F(QuicTransportFunctionsTest, WritePureAckWhenNoWritableBytes) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
@@ -1613,14 +1640,16 @@ TEST_F(QuicTransportFunctionsTest, WritePureAckWhenNoWritableBytes) {
 TEST_F(QuicTransportFunctionsTest, ShouldWriteDataTest) {
   auto conn = createConn();
 
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
       .WillRepeatedly(Return(1500));
   conn->congestionController = std::move(mockCongestionController);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   // Pure acks without an oneRttCipher
@@ -1673,7 +1702,8 @@ TEST_F(QuicTransportFunctionsTest, ShouldWriteDataTestDuringPathValidation) {
   auto conn = createConn();
 
   // Create the CC.
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
   conn->oneRttWriteCipher = test::createNoOpAead();
@@ -1732,7 +1762,8 @@ TEST_F(QuicTransportFunctionsTest, ShouldWriteDataTestDuringPathValidation) {
 
 TEST_F(QuicTransportFunctionsTest, ShouldWriteStreamsNoCipher) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
       .WillRepeatedly(Return(1500));
@@ -1746,7 +1777,8 @@ TEST_F(QuicTransportFunctionsTest, ShouldWriteStreamsNoCipher) {
 
 TEST_F(QuicTransportFunctionsTest, ShouldWritePureAcksNoCipher) {
   auto conn = createConn();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
       .WillRepeatedly(Return(1500));
@@ -1760,7 +1792,8 @@ TEST_F(QuicTransportFunctionsTest, ShouldWritePureAcksNoCipher) {
 TEST_F(QuicTransportFunctionsTest, ShouldWriteDataNoConnFlowControl) {
   auto conn = createConn();
   conn->oneRttWriteCipher = test::createNoOpAead();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
       .WillRepeatedly(Return(1500));
@@ -1988,12 +2021,14 @@ TEST_F(QuicTransportFunctionsTest, TimeoutBasedRetxCountUpdate) {
 TEST_F(QuicTransportFunctionsTest, WriteLimitBytRttFraction) {
   auto conn = createConn();
   conn->lossState.srtt = 50ms;
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn->congestionController = std::move(mockCongestionController);
 
   EventBase evb;
-  auto socket = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+  auto socket =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
   auto rawSocket = socket.get();
 
   auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
diff --git a/quic/api/test/QuicTransportTest.cpp b/quic/api/test/QuicTransportTest.cpp
index f0d30f285..8ae4adce1 100644
--- a/quic/api/test/QuicTransportTest.cpp
+++ b/quic/api/test/QuicTransportTest.cpp
@@ -178,13 +178,13 @@ class QuicTransportTest : public Test {
 
   void SetUp() override {
     std::unique_ptr<MockAsyncUDPSocket> sock =
-        std::make_unique<MockAsyncUDPSocket>(&evb_);
+        std::make_unique<NiceMock<MockAsyncUDPSocket>>(&evb_);
     socket_ = sock.get();
     transport_.reset(
         new TestQuicTransport(&evb_, std::move(sock), connCallback_));
     // Set the write handshake state to tell the client that the handshake has
     // a cipher.
-    auto aead = std::make_unique<MockAead>();
+    auto aead = std::make_unique<NiceMock<MockAead>>();
     aead_ = aead.get();
     EXPECT_CALL(*aead_, _encrypt(_, _, _))
         .WillRepeatedly(
@@ -221,8 +221,8 @@ class QuicTransportTest : public Test {
  protected:
   folly::EventBase evb_;
   MockAsyncUDPSocket* socket_;
-  MockConnectionCallback connCallback_;
-  MockWriteCallback writeCallback_;
+  NiceMock<MockConnectionCallback> connCallback_;
+  NiceMock<MockWriteCallback> writeCallback_;
   MockAead* aead_;
   std::unique_ptr<PacketNumberCipher> headerCipher_;
   std::shared_ptr<TestQuicTransport> transport_;
@@ -333,7 +333,8 @@ void verifyCorrectness(
 TEST_F(QuicTransportTest, WriteDataWithProbing) {
   auto& conn = transport_->getConnectionState();
   // Replace with MockConnectionCallback:
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
 
@@ -372,7 +373,8 @@ TEST_F(QuicTransportTest, WriteDataWithProbing) {
 TEST_F(QuicTransportTest, NotAppLimitedWithLoss) {
   auto& conn = transport_->getConnectionState();
   // Replace with MockConnectionCallback:
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
@@ -395,7 +397,8 @@ TEST_F(QuicTransportTest, NotAppLimitedWithLoss) {
 TEST_F(QuicTransportTest, NotAppLimitedWithNoWritableBytes) {
   auto& conn = transport_->getConnectionState();
   // Replace with MockConnectionCallback:
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
@@ -421,7 +424,8 @@ TEST_F(QuicTransportTest, NotAppLimitedWithNoWritableBytes) {
 TEST_F(QuicTransportTest, NotAppLimitedWithLargeBuffer) {
   auto& conn = transport_->getConnectionState();
   // Replace with MockConnectionCallback:
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
@@ -438,7 +442,8 @@ TEST_F(QuicTransportTest, NotAppLimitedWithLargeBuffer) {
 TEST_F(QuicTransportTest, AppLimited) {
   auto& conn = transport_->getConnectionState();
   // Replace with MockConnectionCallback:
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
@@ -1318,7 +1323,8 @@ TEST_F(QuicTransportTest, BusyWriteLoopDetection) {
   conn.loopDetectorCallback = std::move(mockLoopDetectorCallback);
   ASSERT_FALSE(conn.debugState.needsWriteLoopDetect);
   ASSERT_EQ(0, conn.debugState.currentEmptyLoopCount);
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
@@ -1793,7 +1799,7 @@ TEST_F(QuicTransportTest, DeliveryCallbackClosesTransportOnDelivered) {
 }
 
 TEST_F(QuicTransportTest, InvokeDeliveryCallbacksNothingDelivered) {
-  MockDeliveryCallback mockedDeliveryCallback;
+  NiceMock<MockDeliveryCallback> mockedDeliveryCallback;
   auto stream = transport_->createBidirectionalStream().value();
   auto buf = buildRandomInputData(20);
   EXPECT_CALL(*socket_, write(_, _)).WillRepeatedly(Invoke(bufLength));
@@ -1824,7 +1830,7 @@ TEST_F(QuicTransportTest, InvokeDeliveryCallbacksNothingDelivered) {
 }
 
 TEST_F(QuicTransportTest, InvokeDeliveryCallbacksAllDelivered) {
-  MockDeliveryCallback mockedDeliveryCallback;
+  NiceMock<MockDeliveryCallback> mockedDeliveryCallback;
   auto stream = transport_->createBidirectionalStream().value();
   auto buf = buildRandomInputData(20);
   EXPECT_CALL(*socket_, write(_, _)).WillRepeatedly(Invoke(bufLength));
@@ -1846,7 +1852,8 @@ TEST_F(QuicTransportTest, InvokeDeliveryCallbacksAllDelivered) {
 }
 
 TEST_F(QuicTransportTest, InvokeDeliveryCallbacksPartialDelivered) {
-  MockDeliveryCallback mockedDeliveryCallback1, mockedDeliveryCallback2;
+  NiceMock<MockDeliveryCallback> mockedDeliveryCallback1,
+      mockedDeliveryCallback2;
   auto stream = transport_->createBidirectionalStream().value();
   auto buf = buildRandomInputData(100);
   EXPECT_CALL(*socket_, write(_, _)).WillRepeatedly(Invoke(bufLength));
@@ -1884,7 +1891,8 @@ TEST_F(QuicTransportTest, InvokeDeliveryCallbacksPartialDelivered) {
 }
 
 TEST_F(QuicTransportTest, InvokeDeliveryCallbacksRetxBuffer) {
-  MockDeliveryCallback mockedDeliveryCallback1, mockedDeliveryCallback2;
+  NiceMock<MockDeliveryCallback> mockedDeliveryCallback1,
+      mockedDeliveryCallback2;
   auto stream = transport_->createBidirectionalStream().value();
   auto buf = buildRandomInputData(100);
   EXPECT_CALL(*socket_, write(_, _)).WillRepeatedly(Invoke(bufLength));
@@ -1927,8 +1935,8 @@ TEST_F(QuicTransportTest, InvokeDeliveryCallbacksRetxBuffer) {
 }
 
 TEST_F(QuicTransportTest, InvokeDeliveryCallbacksLossAndRetxBuffer) {
-  MockDeliveryCallback mockedDeliveryCallback1, mockedDeliveryCallback2,
-      mockedDeliveryCallback3;
+  NiceMock<MockDeliveryCallback> mockedDeliveryCallback1,
+      mockedDeliveryCallback2, mockedDeliveryCallback3;
   auto stream = transport_->createBidirectionalStream().value();
   auto buf = buildRandomInputData(100);
   EXPECT_CALL(*socket_, write(_, _)).WillRepeatedly(Invoke(bufLength));
@@ -2291,7 +2299,8 @@ TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
   auto s1 = transport_->createBidirectionalStream().value();
   auto s2 = transport_->createBidirectionalStream().value();
 
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
 
@@ -2471,12 +2480,13 @@ TEST_F(QuicTransportTest, PacedWriteNoDataToWrite) {
 
 TEST_F(QuicTransportTest, PacingWillBurstFirst) {
   auto& conn = transport_->getConnectionState();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   conn.transportSettings.pacingEnabled = true;
   conn.canBePaced = true;
-  auto mockPacer = std::make_unique<MockPacer>();
+  auto mockPacer = std::make_unique<NiceMock<MockPacer>>();
   auto rawPacer = mockPacer.get();
   conn.pacer = std::move(mockPacer);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
@@ -2494,12 +2504,13 @@ TEST_F(QuicTransportTest, PacingWillBurstFirst) {
 TEST_F(QuicTransportTest, AlreadyScheduledPacingNoWrite) {
   transport_->setPacingTimer(TimerHighRes::newTimer(&evb_, 1ms));
   auto& conn = transport_->getConnectionState();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   conn.transportSettings.pacingEnabled = true;
   conn.canBePaced = true;
-  auto mockPacer = std::make_unique<MockPacer>();
+  auto mockPacer = std::make_unique<NiceMock<MockPacer>>();
   auto rawPacer = mockPacer.get();
   conn.pacer = std::move(mockPacer);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
@@ -2526,12 +2537,13 @@ TEST_F(QuicTransportTest, AlreadyScheduledPacingNoWrite) {
 
 TEST_F(QuicTransportTest, NoScheduleIfNoNewData) {
   auto& conn = transport_->getConnectionState();
-  auto mockCongestionController = std::make_unique<MockCongestionController>();
+  auto mockCongestionController =
+      std::make_unique<NiceMock<MockCongestionController>>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
   conn.transportSettings.pacingEnabled = true;
   conn.canBePaced = true;
-  auto mockPacer = std::make_unique<MockPacer>();
+  auto mockPacer = std::make_unique<NiceMock<MockPacer>>();
   auto rawPacer = mockPacer.get();
   conn.pacer = std::move(mockPacer);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
diff --git a/quic/client/test/QuicClientTransportTest.cpp b/quic/client/test/QuicClientTransportTest.cpp
index bdd950d6a..8554b8c66 100644
--- a/quic/client/test/QuicClientTransportTest.cpp
+++ b/quic/client/test/QuicClientTransportTest.cpp
@@ -197,7 +197,7 @@ class QuicClientTransportIntegrationTest : public TestWithParam<TestingParams> {
   std::shared_ptr<fizz::client::FizzClientContext> createClientContext() {
     clientCtx = std::make_shared<fizz::client::FizzClientContext>();
     clientCtx->setSupportedAlpns({"h1q-fb"});
-    clientCtx->setClock(std::make_shared<fizz::test::MockClock>());
+    clientCtx->setClock(std::make_shared<NiceMock<fizz::test::MockClock>>());
     return clientCtx;
   }
 
@@ -325,8 +325,8 @@ class QuicClientTransportIntegrationTest : public TestWithParam<TestingParams> {
   std::string hostname;
   folly::EventBase eventbase_;
   folly::SocketAddress serverAddr;
-  MockConnectionCallback clientConnCallback;
-  MockReadCallback readCb;
+  NiceMock<MockConnectionCallback> clientConnCallback;
+  NiceMock<MockReadCallback> readCb;
   std::shared_ptr<TestingQuicClientTransport> client;
   std::shared_ptr<fizz::server::FizzServerContext> serverCtx;
   std::shared_ptr<fizz::client::FizzClientContext> clientCtx;
@@ -808,7 +808,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttInvalidAppParams) {
 }
 
 TEST_P(QuicClientTransportIntegrationTest, ChangeEventBase) {
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb2;
   folly::ScopedEventBaseThread newEvb;
   expectTransportCallbacks();
   client->start(&clientConnCallback);
@@ -869,7 +869,7 @@ TEST_P(QuicClientTransportIntegrationTest, ResetClient) {
   auto server2Addr = server2->getAddress();
   client->getNonConstConn().peerAddress = server2Addr;
 
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb2;
   bool resetRecvd = false;
   auto streamId2 = client->createBidirectionalStream().value();
   auto f2 = sendRequestAndResponse(data->clone(), streamId2, &readCb2)
@@ -914,7 +914,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestStatelessResetToken) {
   auto server2Addr = server2->getAddress();
   client->getNonConstConn().peerAddress = server2Addr;
 
-  MockReadCallback readCb2;
+  NiceMock<MockReadCallback> readCb2;
   bool resetRecvd = false;
   auto streamId2 = client->createBidirectionalStream().value();
   sendRequestAndResponse(data->clone(), streamId2, &readCb2)
@@ -1303,8 +1303,8 @@ class QuicClientTransportTest : public Test {
       : eventbase_(std::make_unique<folly::EventBase>()) {}
 
   void SetUp() override final {
-    auto socket =
-        std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get());
+    auto socket = std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+        eventbase_.get());
     sock = socket.get();
 
     auto fizzClientContext =
@@ -1688,9 +1688,9 @@ class QuicClientTransportTest : public Test {
  protected:
   std::vector<std::unique_ptr<folly::IOBuf>> socketWrites;
   std::deque<TestReadData> socketReads;
-  MockDeliveryCallback deliveryCallback;
-  MockReadCallback readCb;
-  MockConnectionCallback clientConnCallback;
+  NiceMock<MockDeliveryCallback> deliveryCallback;
+  NiceMock<MockReadCallback> readCb;
+  NiceMock<MockConnectionCallback> clientConnCallback;
   folly::test::MockAsyncUDPSocket* sock;
   std::shared_ptr<DestructionCallback> destructionCallback;
   std::unique_ptr<folly::EventBase> eventbase_;
@@ -1799,8 +1799,8 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceAfterHandshake) {
   auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
   client->setQLogger(mockQLogger);
 
-  auto newSocket =
-      std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get());
+  auto newSocket = std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+      eventbase_.get());
   auto newSocketPtr = newSocket.get();
   EXPECT_CALL(*sock, pauseRead());
   EXPECT_CALL(*sock, close());
@@ -1815,8 +1815,8 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceAfterHandshake) {
 }
 
 TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceNoHandshake) {
-  auto newSocket =
-      std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get());
+  auto newSocket = std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+      eventbase_.get());
   auto newSocketPtr = newSocket.get();
   auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
   EXPECT_CALL(*mockQLogger, addConnectionMigrationUpdate(true)).Times(0);
@@ -2087,7 +2087,8 @@ class QuicClientTransportHappyEyeballsTest : public QuicClientTransportTest {
  public:
   void SetUpChild() override {
     auto secondSocket =
-        std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get());
+        std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+            eventbase_.get());
     secondSock = secondSocket.get();
 
     client->setHappyEyeballsEnabled(true);
@@ -4172,7 +4173,7 @@ TEST_F(QuicClientTransportAfterStartTest, DeliveryCallbackFromWriteChain) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, NotifyPendingWrite) {
-  MockWriteCallback writeCallback;
+  NiceMock<MockWriteCallback> writeCallback;
   EXPECT_CALL(writeCallback, onConnectionWriteReady(_));
   client->notifyPendingWriteOnConnection(&writeCallback);
   loopForWrites();
@@ -4180,7 +4181,7 @@ TEST_F(QuicClientTransportAfterStartTest, NotifyPendingWrite) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, SwitchEvbWhileAsyncEventPending) {
-  MockWriteCallback writeCallback;
+  NiceMock<MockWriteCallback> writeCallback;
   EventBase evb2;
   EXPECT_CALL(writeCallback, onConnectionWriteReady(_)).Times(0);
   client->notifyPendingWriteOnConnection(&writeCallback);
@@ -4640,7 +4641,7 @@ TEST_F(QuicClientTransportAfterStartTest, SendResetSyncOnAck) {
   StreamId streamId = client->createBidirectionalStream().value();
   StreamId streamId2 = client->createBidirectionalStream().value();
 
-  MockDeliveryCallback deliveryCallback2;
+  NiceMock<MockDeliveryCallback> deliveryCallback2;
   auto data = IOBuf::copyBuffer("hello");
   client->writeChain(streamId, data->clone(), true, false, &deliveryCallback);
   client->writeChain(streamId2, data->clone(), true, false, &deliveryCallback2);
@@ -4963,7 +4964,7 @@ class QuicClientTransportPskCacheTest
     : public QuicClientTransportAfterStartTestBase {
  public:
   void SetUpChild() override {
-    mockPskCache_ = std::make_shared<MockQuicPskCache>();
+    mockPskCache_ = std::make_shared<NiceMock<MockQuicPskCache>>();
     client->setPskCache(mockPskCache_);
     QuicClientTransportAfterStartTestBase::SetUpChild();
   }
@@ -5061,7 +5062,7 @@ class QuicZeroRttClientTest : public QuicClientTransportAfterStartTestBase {
     // Ignore path mtu to test negotiation.
     clientSettings.canIgnorePathMTU = true;
     client->setTransportSettings(clientSettings);
-    mockQuicPskCache_ = std::make_shared<MockQuicPskCache>();
+    mockQuicPskCache_ = std::make_shared<NiceMock<MockQuicPskCache>>();
     client->setPskCache(mockQuicPskCache_);
   }
 
@@ -5329,11 +5330,12 @@ class QuicZeroRttHappyEyeballsClientTransportTest
  public:
   void SetUpChild() override {
     client->setHostname(hostname_);
-    mockQuicPskCache_ = std::make_shared<MockQuicPskCache>();
+    mockQuicPskCache_ = std::make_shared<NiceMock<MockQuicPskCache>>();
     client->setPskCache(mockQuicPskCache_);
 
     auto secondSocket =
-        std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get());
+        std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+            eventbase_.get());
     secondSock = secondSocket.get();
 
     client->setHappyEyeballsEnabled(true);
diff --git a/quic/common/test/TestUtils.cpp b/quic/common/test/TestUtils.cpp
index 1c08fe2a6..d879e4ea3 100644
--- a/quic/common/test/TestUtils.cpp
+++ b/quic/common/test/TestUtils.cpp
@@ -147,7 +147,7 @@ std::shared_ptr<fizz::server::FizzServerContext> createServerCtx() {
   serverCtx->setFactory(std::make_shared<QuicFizzFactory>());
   serverCtx->setCertManager(std::move(certManager));
   serverCtx->setOmitEarlyRecordLayer(true);
-  serverCtx->setClock(std::make_shared<fizz::test::MockClock>());
+  serverCtx->setClock(std::make_shared<NiceMock<fizz::test::MockClock>>());
   return serverCtx;
 }
 
@@ -229,7 +229,7 @@ QuicCachedPsk setupZeroRttOnClientCtx(
   psk.version = clientCtx.getSupportedVersions()[0];
   psk.cipher = clientCtx.getSupportedCiphers()[0];
   psk.group = clientCtx.getSupportedGroups()[0];
-  auto mockCert = std::make_shared<fizz::test::MockCert>();
+  auto mockCert = std::make_shared<NiceMock<fizz::test::MockCert>>();
   ON_CALL(*mockCert, getIdentity()).WillByDefault(Return(hostname));
   psk.serverCert = mockCert;
   psk.alpn = clientCtx.getSupportedAlpns()[0];
diff --git a/quic/server/test/QuicServerTest.cpp b/quic/server/test/QuicServerTest.cpp
index b9c618b90..0c8096b28 100644
--- a/quic/server/test/QuicServerTest.cpp
+++ b/quic/server/test/QuicServerTest.cpp
@@ -75,12 +75,13 @@ class SimpleQuicServerWorkerTest : public Test {
 };
 
 TEST_F(SimpleQuicServerWorkerTest, TurnOffPMTU) {
-  auto sock = std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_);
+  auto sock =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   rawSocket_ = sock.get();
   DCHECK(sock->getEventBase());
   EXPECT_CALL(*sock, getNetworkSocket())
       .WillRepeatedly(Return(folly::NetworkSocket()));
-  workerCb_ = std::make_shared<MockWorkerCallback>();
+  workerCb_ = std::make_shared<NiceMock<MockWorkerCallback>>();
   worker_ = std::make_unique<QuicServerWorker>(workerCb_);
   worker_->setSocket(std::move(sock));
   folly::SocketAddress addr("::1", 0);
@@ -100,12 +101,13 @@ class QuicServerWorkerTest : public Test {
  public:
   void SetUp() override {
     fakeAddress_ = folly::SocketAddress("111.111.111.111", 44444);
-    auto sock = std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_);
+    auto sock = std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+        &eventbase_);
     DCHECK(sock->getEventBase());
     socketPtr_ = sock.get();
-    workerCb_ = std::make_shared<MockWorkerCallback>();
+    workerCb_ = std::make_shared<NiceMock<MockWorkerCallback>>();
     worker_ = std::make_unique<QuicServerWorker>(workerCb_);
-    auto transportInfoCb = std::make_unique<MockQuicStats>();
+    auto transportInfoCb = std::make_unique<NiceMock<MockQuicStats>>();
     TransportSettings settings;
     settings.statelessResetTokenSecret = getRandSecret();
     worker_->setTransportSettings(settings);
@@ -136,9 +138,10 @@ class QuicServerWorkerTest : public Test {
     socketFactory_ = std::make_unique<MockQuicUDPSocketFactory>();
     EXPECT_CALL(*socketFactory_, _make(_, _)).WillRepeatedly(Return(nullptr));
     worker_->setNewConnectionSocketFactory(socketFactory_.get());
-    MockConnectionCallback connCb;
-    auto mockSock =
-        std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_);
+    NiceMock<MockConnectionCallback> connCb;
+    std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock =
+        std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+            &eventbase_);
     EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
     transport_.reset(new MockQuicTransport(
         worker_->getEventBase(), std::move(mockSock), connCb, nullptr));
@@ -343,9 +346,9 @@ TEST_F(QuicServerWorkerTest, NoConnFoundTestReset) {
 }
 
 TEST_F(QuicServerWorkerTest, QuicServerWorkerUnbindBeforeCidAvailable) {
-  MockConnectionCallback connCb;
+  NiceMock<MockConnectionCallback> connCb;
   auto mockSock =
-      std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_);
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
   MockQuicTransport::Ptr testTransport = std::make_shared<MockQuicTransport>(
       worker_->getEventBase(), std::move(mockSock), connCb, nullptr);
@@ -513,9 +516,9 @@ TEST_F(QuicServerWorkerTest, QuicServerNewConnection) {
   // transport2's connid available.
   ConnectionId connId2({2, 4, 5, 6});
   folly::SocketAddress clientAddr2("2.3.4.5", 2345);
-  MockConnectionCallback connCb;
+  NiceMock<MockConnectionCallback> connCb;
   auto mockSock =
-      std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_);
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
 
   EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
   MockQuicTransport::Ptr transport2 = std::make_shared<MockQuicTransport>(
@@ -857,12 +860,13 @@ ConnectionId createConnIdForServer(ProcessId server) {
 class QuicServerWorkerTakeoverTest : public Test {
  public:
   void SetUp() override {
-    auto sock = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb_);
+    auto sock =
+        std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb_);
     DCHECK(sock->getEventBase());
     EXPECT_CALL(*sock, getNetworkSocket())
         .WillRepeatedly(Return(folly::NetworkSocket()));
     EXPECT_CALL(*sock, pauseRead());
-    takeoverWorkerCb_ = std::make_shared<MockWorkerCallback>();
+    takeoverWorkerCb_ = std::make_shared<NiceMock<MockWorkerCallback>>();
     takeoverWorker_ = std::make_unique<QuicServerWorker>(takeoverWorkerCb_);
     takeoverWorker_->setSupportedVersions(supportedVersions);
     takeoverWorker_->setSocket(std::move(sock));
@@ -871,7 +875,7 @@ class QuicServerWorkerTakeoverTest : public Test {
         takeoverSocketFactory_.get());
     factory_ = std::make_unique<MockQuicServerTransportFactory>();
     takeoverWorker_->setTransportFactory(factory_.get());
-    auto transportInfoCb = std::make_unique<MockQuicStats>();
+    auto transportInfoCb = std::make_unique<NiceMock<MockQuicStats>>();
     takeoverWorker_->setConnectionIdAlgo(
         std::make_unique<DefaultConnectionIdAlgo>());
     takeoverWorker_->setTransportInfoCallback(std::move(transportInfoCb));
@@ -879,7 +883,7 @@ class QuicServerWorkerTakeoverTest : public Test {
         (MockQuicStats*)takeoverWorker_->getTransportInfoCallback();
 
     auto takeoverSock =
-        std::make_unique<folly::test::MockAsyncUDPSocket>(&evb_);
+        std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb_);
     takeoverSocket_ = takeoverSock.get();
     folly::SocketAddress takeoverAddr;
     EXPECT_CALL(*takeoverSocket_, bind(_));
@@ -906,7 +910,8 @@ class QuicServerWorkerTakeoverTest : public Test {
 };
 
 TEST_F(QuicServerWorkerTakeoverTest, QuicServerTakeoverReInitHandler) {
-  auto takeoverSock = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb_);
+  auto takeoverSock =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb_);
   folly::SocketAddress takeoverAddr;
   EXPECT_CALL(*takeoverSocket_, pauseRead());
 
@@ -1036,7 +1041,8 @@ void QuicServerWorkerTakeoverTest::testPacketForwarding(
     Buf data,
     size_t len,
     ConnectionId connId) {
-  auto writeSock = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb_);
+  auto writeSock =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb_);
   EXPECT_CALL(*takeoverSocketFactory_, _make(_, _))
       .WillOnce(Return(writeSock.get()));
   EXPECT_CALL(*writeSock, bind(_));
@@ -1119,7 +1125,8 @@ TEST_F(QuicServerWorkerTakeoverTest, QuicServerTakeoverProcessForwardedPkt) {
   takeoverWorker_->startPacketForwarding(folly::SocketAddress("0", 0));
 
   // the packet will be forwarded
-  auto writeSock = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb_);
+  auto writeSock =
+      std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb_);
   EXPECT_CALL(*takeoverSocketFactory_, _make(_, _))
       .WillOnce(Return(writeSock.get()));
   EXPECT_CALL(*writeSock, bind(_));
@@ -1254,7 +1261,7 @@ class QuicServerTest : public Test {
     } else {
       EXPECT_CALL(*transportStatsFactory_, make(_))
           .WillRepeatedly(Invoke([&](folly::EventBase* /* unused */) {
-            auto mockInfoCb = std::make_unique<MockQuicStats>();
+            auto mockInfoCb = std::make_unique<NiceMock<MockQuicStats>>();
             return mockInfoCb;
           }));
     }
@@ -1289,9 +1296,10 @@ class QuicServerTest : public Test {
     // create mock transport
     std::shared_ptr<MockQuicTransport> transport;
     eventBase->runInEventBaseThreadAndWait([&] {
-      MockConnectionCallback cb;
-      auto mockSock =
-          std::make_unique<folly::test::MockAsyncUDPSocket>(eventBase);
+      NiceMock<MockConnectionCallback> cb;
+      std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock =
+          std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
+              eventBase);
       EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(serverAddr));
       transport = std::make_shared<MockQuicTransport>(
           eventBase, std::move(mockSock), cb, quic::test::createServerCtx());
@@ -1554,7 +1562,7 @@ class QuicServerTakeoverTest : public Test {
       Buf& data,
       folly::Baton<>& baton) {
     std::shared_ptr<MockQuicTransport> transport;
-    MockConnectionCallback cb;
+    NiceMock<MockConnectionCallback> cb;
     auto makeTransport = [&](
         folly::EventBase * eventBase,
         std::unique_ptr<folly::AsyncUDPSocket> & socket,
@@ -1608,7 +1616,7 @@ class QuicServerTakeoverTest : public Test {
     // setup mock transport stats factory
     auto transportStatsFactory = std::make_unique<MockQuicStatsFactory>();
     auto makeCbForOldServer = [&](folly::EventBase* /* unused */) {
-      oldTransInfoCb_ = new MockQuicStats();
+      oldTransInfoCb_ = new NiceMock<MockQuicStats>();
       std::unique_ptr<MockQuicStats> transportInfoCb;
       transportInfoCb.reset(oldTransInfoCb_);
       return transportInfoCb;
@@ -1649,7 +1657,7 @@ class QuicServerTakeoverTest : public Test {
     // setup mock transport stats factory
     transportStatsFactory = std::make_unique<MockQuicStatsFactory>();
     auto makeCbForNewServer = [&](folly::EventBase* /* unused */) {
-      newTransInfoCb_ = new MockQuicStats();
+      newTransInfoCb_ = new NiceMock<MockQuicStats>();
       std::unique_ptr<MockQuicStats> transportInfoCb;
       transportInfoCb.reset(newTransInfoCb_);
       return transportInfoCb;
@@ -2062,7 +2070,7 @@ TEST_F(QuicServerTest, ZeroRttPacketRoute) {
 
   setUpTransportFactoryForWorkers(evbs);
   std::shared_ptr<MockQuicTransport> transport;
-  MockConnectionCallback cb;
+  NiceMock<MockConnectionCallback> cb;
   folly::Baton<> b;
   // create payload
   StreamId id = 1;
diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp
index e9f09566f..30adfb874 100644
--- a/quic/server/test/QuicServerTransportTest.cpp
+++ b/quic/server/test/QuicServerTransportTest.cpp
@@ -289,7 +289,8 @@ class QuicServerTransportTest : public Test {
     initialDestinationConnectionId->data()[0] ^= 0x1;
     // set server chosen connId with processId = 0 and workerId = 1
     ServerConnectionIdParams params(0, 0, 1);
-    auto sock = std::make_unique<folly::test::MockAsyncUDPSocket>(&evb);
+    auto sock =
+        std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&evb);
     socket = sock.get();
     EXPECT_CALL(*sock, write(_, _))
         .WillRepeatedly(Invoke([&](const SocketAddress&,
@@ -311,7 +312,7 @@ class QuicServerTransportTest : public Test {
     server->setServerConnectionIdParams(params);
     server->getNonConstConn().transportSettings.statelessResetTokenSecret =
         getRandSecret();
-    transportInfoCb_ = std::make_unique<MockQuicStats>();
+    transportInfoCb_ = std::make_unique<NiceMock<MockQuicStats>>();
     server->setTransportInfoCallback(transportInfoCb_.get());
     initializeServerHandshake();
     server->getNonConstConn().handshakeLayer.reset(fakeHandshake);
@@ -672,8 +673,8 @@ class QuicServerTransportTest : public Test {
   EventBase evb;
   SocketAddress serverAddr;
   SocketAddress clientAddr;
-  MockConnectionCallback connCallback;
-  MockRoutingCallback routingCallback;
+  NiceMock<MockConnectionCallback> connCallback;
+  NiceMock<MockRoutingCallback> routingCallback;
   folly::Optional<ConnectionId> clientConnectionId;
   folly::Optional<ConnectionId> initialDestinationConnectionId;
   folly::Optional<ConnectionId> serverConnectionId;