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

net/quic/core/quic_packet_generator_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_packet_generator.h"
 
 #include <cstdint>
 #include <memory>
 #include <string>
 
@@ skipping 383 matching lines @@
   PacketContents contents;
   contents.num_stream_frames = 1;
   CheckPacketContains(contents, 0);
 
   ASSERT_EQ(1u, packets_.size());
   ASSERT_EQ(kDefaultMaxPacketSize, generator_.GetCurrentMaxPacketLength());
   EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeData_EmptyData) {
-  EXPECT_DFATAL(generator_.ConsumeData(kHeadersStreamId, MakeIOVector(""), 0,
-                                       false, nullptr),
-                "Attempt to consume empty data without FIN.");
+  EXPECT_QUIC_BUG(generator_.ConsumeData(kHeadersStreamId, MakeIOVector(""), 0,
+                                         false, nullptr),
+                  "Attempt to consume empty data without FIN.");
 }
 
 TEST_F(QuicPacketGeneratorTest,
        ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
   delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
                          nullptr);
   QuicConsumedData consumed =
@@ skipping 418 matching lines @@
       .WillOnce(Return(QuicFrame(&ack_frame_)));
   EXPECT_CALL(delegate_, PopulateStopWaitingFrame(_));
   // Generator should have queued control frames, and creator should be empty.
   EXPECT_TRUE(generator_.HasQueuedFrames());
   EXPECT_FALSE(creator_->HasPendingFrames());
 
   // This will not serialize any packets, because of the invalid frame.
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET, _,
                                    ConnectionCloseSource::FROM_SELF));
-  EXPECT_DFATAL(generator_.FinishBatchOperations(),
-                "packet_number_length 1 is too small "
-                "for least_unacked_delta: 1001");
+  EXPECT_QUIC_BUG(generator_.FinishBatchOperations(),
+                  "packet_number_length 1 is too small "
+                  "for least_unacked_delta: 1001");
 }
 
 TEST_F(QuicPacketGeneratorTest, SetCurrentPath) {
   delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   QuicConsumedData consumed = generator_.ConsumeData(
       kHeadersStreamId, MakeIOVector("foo"), 2, true, nullptr);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasQueuedFrames());
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(creator_));
   // Does not change current path.
   generator_.SetCurrentPath(kDefaultPathId, 1, 0);
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(creator_));
 
   // Try to switch path when a packet is under construction.
   QuicPathId kTestPathId1 = 1;
-  EXPECT_DFATAL(generator_.SetCurrentPath(kTestPathId1, 1, 0),
-                "Unable to change paths when a packet is under construction");
+  EXPECT_QUIC_BUG(generator_.SetCurrentPath(kTestPathId1, 1, 0),
+                  "Unable to change paths when a packet is under construction");
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(creator_));
 
   // Try to switch path after current open packet gets serialized.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   generator_.FlushAllQueuedFrames();
   EXPECT_FALSE(generator_.HasQueuedFrames());
   generator_.SetCurrentPath(kTestPathId1, 1, 0);
   EXPECT_EQ(kTestPathId1, QuicPacketCreatorPeer::GetCurrentPath(creator_));
 }
 
 }  // namespace test
 }  // namespace net