Deprecate FLAGS_quic_always_write_queued_retransmissions.

net/quic/quic_multipath_sent_packet_manager_test.cc

 #include "net/quic/quic_multipath_sent_packet_manager.h"
 
 #include "net/quic/test_tools/quic_multipath_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Return;
 using testing::StrictMock;
@@ skipping 74 matching lines @@
   frame3.path_id = kTestPathId3;
   EXPECT_CALL(*manager_0_, OnIncomingAck(_, QuicTime::Zero()));
   EXPECT_CALL(*manager_1_, OnIncomingAck(_, QuicTime::Zero()));
   EXPECT_CALL(*manager_2_, OnIncomingAck(_, QuicTime::Zero())).Times(0);
   multipath_manager_.OnIncomingAck(frame0, QuicTime::Zero());
   multipath_manager_.OnIncomingAck(frame1, QuicTime::Zero());
   multipath_manager_.OnIncomingAck(frame2, QuicTime::Zero());
   multipath_manager_.OnIncomingAck(frame3, QuicTime::Zero());
 }
 
-TEST_F(QuicMultipathSentPacketManagerTest, IsUnacked) {
-  EXPECT_CALL(*manager_0_, IsUnacked(kDefaultPathId, 1)).WillOnce(Return(true));
-  EXPECT_CALL(*manager_1_, IsUnacked(kTestPathId1, 2)).WillOnce(Return(false));
-  EXPECT_CALL(*manager_2_, IsUnacked(kTestPathId2, 3)).WillOnce(Return(true));
-  EXPECT_TRUE(multipath_manager_.IsUnacked(kDefaultPathId, 1));
-  EXPECT_FALSE(multipath_manager_.IsUnacked(kTestPathId1, 2));
-  EXPECT_TRUE(multipath_manager_.IsUnacked(kTestPathId2, 3));
-  /*
-  EXPECT_DFATAL(multipath_manager_.IsUnacked(kTestPathId3, 4), "");
-  */
-}
-
-TEST_F(QuicMultipathSentPacketManagerTest, HasRetransmittableFrames) {
-  EXPECT_CALL(*manager_0_, HasRetransmittableFrames(kDefaultPathId, 1))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*manager_1_, HasRetransmittableFrames(kTestPathId1, 2))
-      .WillOnce(Return(false));
-  EXPECT_CALL(*manager_2_, HasRetransmittableFrames(kTestPathId2, 3))
-      .WillOnce(Return(true));
-  EXPECT_TRUE(multipath_manager_.HasRetransmittableFrames(kDefaultPathId, 1));
-  EXPECT_FALSE(multipath_manager_.HasRetransmittableFrames(kTestPathId1, 2));
-  EXPECT_TRUE(multipath_manager_.HasRetransmittableFrames(kTestPathId2, 3));
-  /*
-  EXPECT_DFATAL(multipath_manager_.HasRetransmittableFrames(kTestPathId3, 4),
-                "");
-  */
-}
-
 TEST_F(QuicMultipathSentPacketManagerTest, RetransmitUnackedPackets) {
   EXPECT_CALL(*manager_0_, RetransmitUnackedPackets(HANDSHAKE_RETRANSMISSION));
   multipath_manager_.RetransmitUnackedPackets(HANDSHAKE_RETRANSMISSION);
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, MaybeRetransmitTailLossProbe) {
   EXPECT_CALL(*manager_0_, MaybeRetransmitTailLossProbe())
       .WillOnce(Return(false));
   EXPECT_CALL(*manager_1_, MaybeRetransmitTailLossProbe())
       .WillOnce(Return(false));
@@ skipping 38 matching lines @@
   EXPECT_TRUE(multipath_manager_.HasUnackedPackets());
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, GetLeastUnacked) {
   EXPECT_CALL(*manager_0_, GetLeastUnacked(kDefaultPathId)).WillOnce(Return(2));
   EXPECT_CALL(*manager_1_, GetLeastUnacked(kTestPathId1)).WillOnce(Return(3));
   EXPECT_CALL(*manager_2_, GetLeastUnacked(kTestPathId2)).WillOnce(Return(4));
   EXPECT_EQ(2u, multipath_manager_.GetLeastUnacked(kDefaultPathId));
   EXPECT_EQ(3u, multipath_manager_.GetLeastUnacked(kTestPathId1));
   EXPECT_EQ(4u, multipath_manager_.GetLeastUnacked(kTestPathId2));
-  EXPECT_EQ(0u, multipath_manager_.GetLeastUnacked(kTestPathId3));
+  EXPECT_DFATAL(multipath_manager_.GetLeastUnacked(kTestPathId3), "");
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, OnPacketSent) {
   SerializedPacket packet0(kDefaultPathId, 1, PACKET_6BYTE_PACKET_NUMBER,
                            nullptr, 1250, 0u, false, false);
   SerializedPacket packet1(kTestPathId1, 1, PACKET_6BYTE_PACKET_NUMBER, nullptr,
                            1250, 0u, false, false);
   SerializedPacket packet2(kTestPathId2, 1, PACKET_6BYTE_PACKET_NUMBER, nullptr,
                            1250, 0u, false, false);
   SerializedPacket packet3(kTestPathId3, 1, PACKET_6BYTE_PACKET_NUMBER, nullptr,
@@ skipping 104 matching lines @@
   EXPECT_CALL(*manager_2_, OnConnectionMigration(_, _)).Times(0);
   multipath_manager_.OnConnectionMigration(kDefaultPathId, PORT_CHANGE);
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_MULTIPATH_PATH_NOT_ACTIVE, _, _));
   /*
   EXPECT_DFATAL(
       multipath_manager_.OnConnectionMigration(kTestPathId2, PORT_CHANGE), "");
   */
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_MULTIPATH_PATH_DOES_NOT_EXIST, _, _));
-  multipath_manager_.OnConnectionMigration(kTestPathId3, PORT_CHANGE);
+  EXPECT_DFATAL(
+      multipath_manager_.OnConnectionMigration(kTestPathId3, PORT_CHANGE), "");
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, IsHandshakeConfirmed) {
   EXPECT_CALL(*manager_0_, IsHandshakeConfirmed()).WillOnce(Return(true));
   EXPECT_TRUE(multipath_manager_.IsHandshakeConfirmed());
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, SetDebugDelegate) {
   EXPECT_CALL(*manager_0_, SetDebugDelegate(nullptr));
   EXPECT_CALL(*manager_1_, SetDebugDelegate(nullptr));
   EXPECT_CALL(*manager_2_, SetDebugDelegate(nullptr));
   multipath_manager_.SetDebugDelegate(nullptr);
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, GetLargestObserved) {
   EXPECT_CALL(*manager_0_, GetLargestObserved(kDefaultPathId))
       .WillOnce(Return(10));
   EXPECT_CALL(*manager_1_, GetLargestObserved(kTestPathId1))
       .WillOnce(Return(11));
   EXPECT_CALL(*manager_2_, GetLargestObserved(kTestPathId2))
       .WillOnce(Return(12));
   EXPECT_EQ(10u, multipath_manager_.GetLargestObserved(kDefaultPathId));
   EXPECT_EQ(11u, multipath_manager_.GetLargestObserved(kTestPathId1));
   EXPECT_EQ(12u, multipath_manager_.GetLargestObserved(kTestPathId2));
-  EXPECT_DFATAL(multipath_manager_.GetLargestObserved(kTestPathId3), "");
+  EXPECT_EQ(0u, multipath_manager_.GetLargestObserved(kTestPathId3));
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, GetLargestSentPacket) {
   EXPECT_CALL(*manager_0_, GetLargestSentPacket(kDefaultPathId))
       .WillOnce(Return(10));
   EXPECT_CALL(*manager_1_, GetLargestSentPacket(kTestPathId1))
       .WillOnce(Return(11));
   EXPECT_CALL(*manager_2_, GetLargestSentPacket(kTestPathId2))
       .WillOnce(Return(12));
   EXPECT_EQ(10u, multipath_manager_.GetLargestSentPacket(kDefaultPathId));
   EXPECT_EQ(11u, multipath_manager_.GetLargestSentPacket(kTestPathId1));
   EXPECT_EQ(12u, multipath_manager_.GetLargestSentPacket(kTestPathId2));
   EXPECT_EQ(0u, multipath_manager_.GetLargestSentPacket(kTestPathId3));
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, GetLeastPacketAwaitedByPeer) {
   EXPECT_CALL(*manager_0_, GetLeastPacketAwaitedByPeer(kDefaultPathId))
       .WillOnce(Return(10));
   EXPECT_CALL(*manager_1_, GetLeastPacketAwaitedByPeer(kTestPathId1))
       .WillOnce(Return(11));
   EXPECT_CALL(*manager_2_, GetLeastPacketAwaitedByPeer(kTestPathId2))
       .WillOnce(Return(12));
   EXPECT_EQ(10u,
             multipath_manager_.GetLeastPacketAwaitedByPeer(kDefaultPathId));
   EXPECT_EQ(11u, multipath_manager_.GetLeastPacketAwaitedByPeer(kTestPathId1));
   EXPECT_EQ(12u, multipath_manager_.GetLeastPacketAwaitedByPeer(kTestPathId2));
-  EXPECT_EQ(0u, multipath_manager_.GetLeastPacketAwaitedByPeer(kTestPathId3));
+  EXPECT_DFATAL(multipath_manager_.GetLeastPacketAwaitedByPeer(kTestPathId3),
+                "");
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, SetNetworkChangeVisitor) {
   EXPECT_CALL(*manager_0_, SetNetworkChangeVisitor(nullptr));
   EXPECT_CALL(*manager_1_, SetNetworkChangeVisitor(nullptr));
   multipath_manager_.SetNetworkChangeVisitor(nullptr);
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, InSlowStart) {
   EXPECT_CALL(*manager_0_, InSlowStart()).WillOnce(Return(true));
   EXPECT_TRUE(multipath_manager_.InSlowStart());
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, GetConsecutiveRtoCount) {
   EXPECT_CALL(*manager_0_, GetConsecutiveRtoCount()).WillOnce(Return(4));
   EXPECT_EQ(4u, multipath_manager_.GetConsecutiveRtoCount());
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, GetConsecutiveTlpCount) {
   EXPECT_CALL(*manager_0_, GetConsecutiveTlpCount()).WillOnce(Return(3));
   EXPECT_EQ(3u, multipath_manager_.GetConsecutiveTlpCount());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net