Create EXPECT_QUIC_BUG macro, and modify QUIC tests to use it.

net/quic/core/quic_multipath_sent_packet_manager_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/core/quic_multipath_sent_packet_manager.h"
 
 #include "net/quic/core/quic_bug_tracker.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"
@@ skipping 18 matching lines @@
   QuicMultipathSentPacketManagerTest()
       : manager_0_(new StrictMock<MockSentPacketManager>),
         manager_1_(new StrictMock<MockSentPacketManager>),
         manager_2_(new StrictMock<MockSentPacketManager>),
         multipath_manager_(manager_0_, &delegate_) {
     // Paths 0 and 1 are active, and path 2 is closing.
     QuicMultipathSentPacketManagerPeer::AddPathWithActiveState(
         &multipath_manager_, manager_1_);
     QuicMultipathSentPacketManagerPeer::AddPathWithCloseState(
         &multipath_manager_, manager_2_);
-    FLAGS_quic_always_log_bugs_for_tests = true;
   }
 
   ~QuicMultipathSentPacketManagerTest() override {}
 
   MockSentPacketManager* manager_0_;
   MockSentPacketManager* manager_1_;
   MockSentPacketManager* manager_2_;
   QuicMultipathSentPacketManager multipath_manager_;
   MockClock clock_;
   StrictMock<MockConnectionCloseDelegate> delegate_;
@@ skipping 99 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_DFATAL(multipath_manager_.GetLeastUnacked(kTestPathId3), "");
+  EXPECT_QUIC_BUG(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,
                            1250, 0u, false, false);
   EXPECT_CALL(*manager_0_,
               OnPacketSent(&packet0, kInvalidPathId, 0, clock_.Now(),
                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
   multipath_manager_.OnPacketSent(&packet0, kInvalidPathId, 0, clock_.Now(),
                                   NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
   EXPECT_CALL(*manager_1_,
               OnPacketSent(&packet1, kInvalidPathId, 0, clock_.Now(),
                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
   multipath_manager_.OnPacketSent(&packet1, kInvalidPathId, 0, clock_.Now(),
                                   NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
   EXPECT_CALL(*manager_2_, OnPacketSent(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_MULTIPATH_PATH_NOT_ACTIVE, _, _));
-  EXPECT_DFATAL(multipath_manager_.OnPacketSent(
-                    &packet2, kInvalidPathId, 0, clock_.Now(),
-                    NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA),
-                "");
+  EXPECT_QUIC_BUG(multipath_manager_.OnPacketSent(
+                      &packet2, kInvalidPathId, 0, clock_.Now(),
+                      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA),
+                  "");
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_MULTIPATH_PATH_DOES_NOT_EXIST, _, _));
-  EXPECT_DFATAL(multipath_manager_.OnPacketSent(
-                    &packet3, kInvalidPathId, 0, clock_.Now(),
-                    NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA),
-                "");
+  EXPECT_QUIC_BUG(multipath_manager_.OnPacketSent(
+                      &packet3, kInvalidPathId, 0, clock_.Now(),
+                      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA),
+                  "");
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, OnRetransmissionTimeout) {
   QuicTime time0 = clock_.Now() + QuicTime::Delta::FromMilliseconds(50);
   QuicTime time1 = clock_.Now() + QuicTime::Delta::FromMilliseconds(100);
   EXPECT_CALL(*manager_0_, GetRetransmissionTime()).WillOnce(Return(time0));
   EXPECT_CALL(*manager_1_, GetRetransmissionTime()).WillOnce(Return(time1));
   EXPECT_CALL(*manager_0_, OnRetransmissionTimeout());
   multipath_manager_.OnRetransmissionTimeout();
 }
@@ skipping 57 matching lines @@
   EXPECT_CALL(*manager_2_, CancelRetransmissionsForStream(1));
   multipath_manager_.CancelRetransmissionsForStream(1);
 }
 
 TEST_F(QuicMultipathSentPacketManagerTest, OnConnectionMigration) {
   EXPECT_CALL(*manager_0_, OnConnectionMigration(kDefaultPathId, PORT_CHANGE));
   EXPECT_CALL(*manager_2_, OnConnectionMigration(_, _)).Times(0);
   multipath_manager_.OnConnectionMigration(kDefaultPathId, PORT_CHANGE);
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_MULTIPATH_PATH_NOT_ACTIVE, _, _));
-  EXPECT_DFATAL(
+  EXPECT_QUIC_BUG(
       multipath_manager_.OnConnectionMigration(kTestPathId2, PORT_CHANGE), "");
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_MULTIPATH_PATH_DOES_NOT_EXIST, _, _));
-  EXPECT_DFATAL(
+  EXPECT_QUIC_BUG(
       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_QUIC_BUG(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_DFATAL(multipath_manager_.GetLargestSentPacket(kTestPathId3), "");
+  EXPECT_QUIC_BUG(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_DFATAL(multipath_manager_.GetLeastPacketAwaitedByPeer(kTestPathId3),
-                "");
+  EXPECT_QUIC_BUG(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));
@@ skipping 13 matching lines @@
 TEST_F(QuicMultipathSentPacketManagerTest, OnApplicationLimited) {
   EXPECT_CALL(*manager_0_, OnApplicationLimited()).Times(1);
   EXPECT_CALL(*manager_1_, OnApplicationLimited()).Times(1);
   EXPECT_CALL(*manager_2_, OnApplicationLimited()).Times(0);
   multipath_manager_.OnApplicationLimited();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net