diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index c3ca92c..6f41069 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -69,6 +69,13 @@
   ParsedQuicVersionVector supported_versions;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  std::string rv = ParsedQuicVersionVectorToString(p.supported_versions);
+  std::replace(rv.begin(), rv.end(), ',', '_');
+  return rv;
+}
+
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
@@ -363,7 +370,8 @@
 
 INSTANTIATE_TEST_SUITE_P(CryptoServerTests,
                          CryptoServerTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(CryptoServerTest, BadSNI) {
   // clang-format off
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index dfaa9ec..7acae48 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -114,6 +114,19 @@
   QuicTag priority_tag;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  std::string rv = QuicStrCat(
+      ParsedQuicVersionToString(p.negotiated_version), "_Server_",
+      ParsedQuicVersionVectorToString(p.server_supported_versions), "_Client_",
+      ParsedQuicVersionVectorToString(p.client_supported_versions), "_",
+      QuicTagToString(p.congestion_control_tag), "_",
+      QuicTagToString(p.priority_tag));
+  std::replace(rv.begin(), rv.end(), ',', '_');
+  std::replace(rv.begin(), rv.end(), ' ', '_');
+  return rv;
+}
+
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams(bool use_tls_handshake) {
   QuicFlagSaver flags;
@@ -592,13 +605,15 @@
 // Run all end to end tests with all supported versions.
 INSTANTIATE_TEST_SUITE_P(EndToEndTests,
                          EndToEndTest,
-                         ::testing::ValuesIn(GetTestParams(false)));
+                         ::testing::ValuesIn(GetTestParams(false)),
+                         ::testing::PrintToStringParamName());
 
 class EndToEndTestWithTls : public EndToEndTest {};
 
 INSTANTIATE_TEST_SUITE_P(EndToEndTestsWithTls,
                          EndToEndTestWithTls,
-                         ::testing::ValuesIn(GetTestParams(true)));
+                         ::testing::ValuesIn(GetTestParams(true)),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(EndToEndTestWithTls, HandshakeSuccessful) {
   ASSERT_TRUE(Initialize());
@@ -3120,7 +3135,8 @@
 // Run all server push end to end tests with all supported versions.
 INSTANTIATE_TEST_SUITE_P(EndToEndTestsServerPush,
                          EndToEndTestServerPush,
-                         ::testing::ValuesIn(GetTestParams(false)));
+                         ::testing::ValuesIn(GetTestParams(false)),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(EndToEndTestServerPush, ServerPush) {
   ASSERT_TRUE(Initialize());
@@ -3845,7 +3861,8 @@
 
 INSTANTIATE_TEST_SUITE_P(EndToEndPacketReorderingTests,
                          EndToEndPacketReorderingTest,
-                         testing::ValuesIn(GetTestParams(false)));
+                         ::testing::ValuesIn(GetTestParams(false)),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(EndToEndPacketReorderingTest, ReorderedConnectivityProbing) {
   ASSERT_TRUE(Initialize());
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 2f2db8d..b4bdb28 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -162,6 +162,13 @@
   Perspective perspective;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& tp) {
+  return QuicStrCat(
+      ParsedQuicVersionToString(tp.version), "_",
+      (tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
+}
+
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
@@ -374,7 +381,8 @@
 // Run all tests with each version and perspective (client or server).
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicHeadersStreamTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicHeadersStreamTest, StreamId) {
   EXPECT_EQ(QuicUtils::GetHeadersStreamId(connection_->transport_version()),
diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc
index 5eeb466..6914681 100644
--- a/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -23,18 +23,31 @@
 struct TestParams {
   TestParams(const ParsedQuicVersion& version, Perspective perspective)
       : version(version), perspective(perspective) {
-    QUIC_LOG(INFO) << "TestParams: version: "
-                   << ParsedQuicVersionToString(version)
-                   << ", perspective: " << perspective;
+    QUIC_LOG(INFO) << "TestParams: " << *this;
   }
 
   TestParams(const TestParams& other)
       : version(other.version), perspective(other.perspective) {}
 
+  friend std::ostream& operator<<(std::ostream& os, const TestParams& tp) {
+    os << "{ version: " << ParsedQuicVersionToString(tp.version)
+       << ", perspective: "
+       << (tp.perspective == Perspective::IS_CLIENT ? "client" : "server")
+       << "}";
+    return os;
+  }
+
   ParsedQuicVersion version;
   Perspective perspective;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& tp) {
+  return QuicStrCat(
+      ParsedQuicVersionToString(tp.version), "_",
+      (tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
+}
+
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
@@ -120,7 +133,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicReceiveControlStreamTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicReceiveControlStreamTest, ResetControlStream) {
   EXPECT_TRUE(receive_control_stream_->is_static());
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index e989e22..3d9de83 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -21,18 +21,31 @@
 struct TestParams {
   TestParams(const ParsedQuicVersion& version, Perspective perspective)
       : version(version), perspective(perspective) {
-    QUIC_LOG(INFO) << "TestParams: version: "
-                   << ParsedQuicVersionToString(version)
-                   << ", perspective: " << perspective;
+    QUIC_LOG(INFO) << "TestParams: " << *this;
   }
 
   TestParams(const TestParams& other)
       : version(other.version), perspective(other.perspective) {}
 
+  friend std::ostream& operator<<(std::ostream& os, const TestParams& tp) {
+    os << "{ version: " << ParsedQuicVersionToString(tp.version)
+       << ", perspective: "
+       << (tp.perspective == Perspective::IS_CLIENT ? "client" : "server")
+       << "}";
+    return os;
+  }
+
   ParsedQuicVersion version;
   Perspective perspective;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& tp) {
+  return QuicStrCat(
+      ParsedQuicVersionToString(tp.version), "_",
+      (tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
+}
+
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
@@ -82,7 +95,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSendControlStreamTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSendControlStreamTest, WriteSettings) {
   session_.set_qpack_maximum_dynamic_table_capacity(255);
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 2570d63..89dbf04 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -228,7 +228,9 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicServerSessionBaseTest,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
+
 TEST_P(QuicServerSessionBaseTest, CloseStreamDueToReset) {
   // Open a stream, then reset it.
   // Send two bytes of payload to open it.
@@ -693,7 +695,8 @@
 
 INSTANTIATE_TEST_SUITE_P(StreamMemberLifetimeTests,
                          StreamMemberLifetimeTest,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 // Trigger an operation which causes an async invocation of
 // ProofSource::GetProof.  Delay the completion of the operation until after the
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index f8a0a0f..3e951b3 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -182,7 +182,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSpdyClientSessionTest,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSpdyClientSessionTest, CryptoConnect) {
   CompleteCryptoHandshake();
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index be6a162..6f8450e 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -101,7 +101,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSpdyClientStreamTest,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSpdyClientStreamTest, TestReceivingIllegalResponseStatusCode) {
   headers_[":status"] = "200 ok";
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 8ea04f8..f2362fc 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -418,7 +418,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSpdySessionTestServer,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSpdySessionTestServer, UsesPendingStreams) {
   if (!VersionHasStreamType(transport_version())) {
@@ -1687,7 +1688,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSpdySessionTestClient,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSpdySessionTestClient, UsesPendingStreams) {
   if (!VersionHasStreamType(transport_version())) {
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index b1f6672..327b952 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -299,7 +299,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSpdyStreamTest,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSpdyStreamTest, ProcessHeaderList) {
   Initialize(kShouldProcessData);
@@ -2094,7 +2095,8 @@
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSpdyStreamIncrementalConsumptionTest,
                          ::testing::Values(ParsedQuicVersion{PROTOCOL_TLS1_3,
-                                                             QUIC_VERSION_99}));
+                                                             QUIC_VERSION_99}),
+                         ::testing::PrintToStringParamName());
 
 // Test that stream bytes are consumed (by calling
 // sequencer()->MarkConsumed()) incrementally, as soon as possible.
diff --git a/quic/core/quic_arena_scoped_ptr_test.cc b/quic/core/quic_arena_scoped_ptr_test.cc
index 109fd37..5b7548a 100644
--- a/quic/core/quic_arena_scoped_ptr_test.cc
+++ b/quic/core/quic_arena_scoped_ptr_test.cc
@@ -21,6 +21,18 @@
   std::vector<char> buffer;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParam& p) {
+  switch (p) {
+    case TestParam::kFromHeap:
+      return "heap";
+    case TestParam::kFromArena:
+      return "arena";
+  }
+  DCHECK(false);
+  return "?";
+}
+
 class QuicArenaScopedPtrParamTest : public QuicTestWithParam<TestParam> {
  protected:
   QuicArenaScopedPtr<TestObject> CreateObject(uintptr_t value) {
@@ -45,7 +57,8 @@
 INSTANTIATE_TEST_SUITE_P(QuicArenaScopedPtrParamTest,
                          QuicArenaScopedPtrParamTest,
                          testing::Values(TestParam::kFromHeap,
-                                         TestParam::kFromArena));
+                                         TestParam::kFromArena),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicArenaScopedPtrParamTest, NullObjects) {
   QuicArenaScopedPtr<TestObject> def;
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index fe04008..080912e 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -29,7 +29,8 @@
 // Run all tests with all versions of QUIC.
 INSTANTIATE_TEST_SUITE_P(QuicConfigTests,
                          QuicConfigTest,
-                         ::testing::ValuesIn(AllSupportedTransportVersions()));
+                         ::testing::ValuesIn(AllSupportedTransportVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicConfigTest, SetDefaults) {
   EXPECT_EQ(kMinimumFlowControlSendWindow,
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index fd29785..4ca06b3 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -878,19 +878,19 @@
         ack_response(ack_response),
         no_stop_waiting(no_stop_waiting) {}
 
-  friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
-    os << "{ client_version: " << ParsedQuicVersionToString(p.version)
-       << " ack_response: "
-       << (p.ack_response == AckResponse::kDefer ? "defer" : "immediate")
-       << " no_stop_waiting: " << p.no_stop_waiting << " }";
-    return os;
-  }
-
   ParsedQuicVersion version;
   AckResponse ack_response;
   bool no_stop_waiting;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  return QuicStrCat(
+      ParsedQuicVersionToString(p.version), "_",
+      (p.ack_response == AckResponse::kDefer ? "defer" : "immediate"), "_",
+      (p.no_stop_waiting ? "No" : ""), "StopWaiting");
+}
+
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams() {
   QuicFlagSaver flags;
@@ -900,14 +900,12 @@
   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
     for (AckResponse ack_response :
          {AckResponse::kDefer, AckResponse::kImmediate}) {
-      for (bool no_stop_waiting : {true, false}) {
-        // After version 43, never use STOP_WAITING.
+      params.push_back(
+          TestParams(all_supported_versions[i], ack_response, true));
+      if (!VersionHasIetfInvariantHeader(
+              all_supported_versions[i].transport_version)) {
         params.push_back(
-            TestParams(all_supported_versions[i], ack_response,
-                       !VersionHasIetfInvariantHeader(
-                           all_supported_versions[i].transport_version)
-                           ? no_stop_waiting
-                           : true));
+            TestParams(all_supported_versions[i], ack_response, false));
       }
     }
   }
@@ -962,6 +960,7 @@
         connection_id_included_(CONNECTION_ID_PRESENT),
         notifier_(&connection_),
         connection_close_frame_count_(0) {
+    QUIC_DVLOG(2) << "QuicConnectionTest(" << PrintToString(GetParam()) << ")";
     SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     connection_.set_defer_send_in_response_to_packets(GetParam().ack_response ==
                                                       AckResponse::kDefer);
@@ -1636,7 +1635,8 @@
 // Run all end to end tests with all supported versions.
 INSTANTIATE_TEST_SUITE_P(SupportedVersion,
                          QuicConnectionTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 // These two tests ensure that the QuicErrorCode mapping works correctly.
 // Both tests expect to see a Google QUIC close if not running IETF QUIC.
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index de47c68..e2ccfde 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -170,7 +170,10 @@
   ParsedQuicVersionVector supported_versions_ = AllSupportedVersions();
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests, QuicCryptoServerStreamTest, testing::Bool());
+INSTANTIATE_TEST_SUITE_P(Tests,
+                         QuicCryptoServerStreamTest,
+                         ::testing::Bool(),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicCryptoServerStreamTest, NotInitiallyConected) {
   Initialize();
@@ -332,7 +335,8 @@
 
 INSTANTIATE_TEST_SUITE_P(MoreTests,
                          QuicCryptoServerStreamTestWithFailingProofSource,
-                         testing::Bool());
+                         ::testing::Bool(),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicCryptoServerStreamTestWithFailingProofSource, Test) {
   Initialize();
@@ -366,7 +370,8 @@
 
 INSTANTIATE_TEST_SUITE_P(YetMoreTests,
                          QuicCryptoServerStreamTestWithFakeProofSource,
-                         testing::Bool());
+                         ::testing::Bool(),
+                         ::testing::PrintToStringParamName());
 
 // Regression test for b/35422225, in which multiple CHLOs arriving on the same
 // connection in close succession could cause a crash, especially when the use
diff --git a/quic/core/quic_data_writer_test.cc b/quic/core/quic_data_writer_test.cc
index 64ad5dd..60abf96 100644
--- a/quic/core/quic_data_writer_test.cc
+++ b/quic/core/quic_data_writer_test.cc
@@ -27,15 +27,15 @@
 struct TestParams {
   explicit TestParams(Endianness endianness) : endianness(endianness) {}
 
-  friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
-    os << "{ " << (p.endianness == NETWORK_BYTE_ORDER ? "network" : "host")
-       << " byte order }";
-    return os;
-  }
-
   Endianness endianness;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  return QuicStrCat((p.endianness == NETWORK_BYTE_ORDER ? "Network" : "Host"),
+                    "ByteOrder");
+}
+
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
   for (Endianness endianness : {NETWORK_BYTE_ORDER, HOST_BYTE_ORDER}) {
@@ -48,7 +48,8 @@
 
 INSTANTIATE_TEST_SUITE_P(QuicDataWriterTests,
                          QuicDataWriterTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicDataWriterTest, SanityCheckUFloat16Consts) {
   // Check the arithmetic on the constants - otherwise the values below make
diff --git a/quic/core/quic_epoll_alarm_factory_test.cc b/quic/core/quic_epoll_alarm_factory_test.cc
index ac950c6..88b27bc 100644
--- a/quic/core/quic_epoll_alarm_factory_test.cc
+++ b/quic/core/quic_epoll_alarm_factory_test.cc
@@ -42,7 +42,8 @@
 
 INSTANTIATE_TEST_SUITE_P(UseArena,
                          QuicEpollAlarmFactoryTest,
-                         ::testing::ValuesIn({true, false}));
+                         ::testing::ValuesIn({true, false}),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicEpollAlarmFactoryTest, CreateAlarm) {
   QuicArenaScopedPtr<TestDelegate> delegate =
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 728214a..9211d68 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -569,11 +569,6 @@
 
 using PacketFragments = std::vector<struct PacketFragment>;
 
-// Used by ::testing::PrintToStringParamName().
-std::string PrintToString(const ParsedQuicVersion& version) {
-  return ParsedQuicVersionToString(version);
-}
-
 class QuicFramerTest : public QuicTestWithParam<ParsedQuicVersion> {
  public:
   QuicFramerTest()
@@ -600,7 +595,6 @@
     framer_.set_visitor(&visitor_);
     framer_.InferPacketHeaderTypeFromVersion();
     visitor_.set_framer(&framer_);
-    QUIC_DVLOG(2) << "QuicFramerTest(" << PrintToString(version_) << ")";
   }
 
   void SetDecrypterLevel(EncryptionLevel level) {
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 8d79cc4..c2f078f 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -45,16 +45,16 @@
   TestParams(ParsedQuicVersion version, bool version_serialization)
       : version(version), version_serialization(version_serialization) {}
 
-  friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
-    os << "{ version: " << ParsedQuicVersionToString(p.version)
-       << " include version: " << p.version_serialization << " }";
-    return os;
-  }
-
   ParsedQuicVersion version;
   bool version_serialization;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  return QuicStrCat(ParsedQuicVersionToString(p.version), "_",
+                    (p.version_serialization ? "Include" : "No"), "Version");
+}
+
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
@@ -288,7 +288,8 @@
 // length of truncated connection id.
 INSTANTIATE_TEST_SUITE_P(QuicPacketCreatorTests,
                          QuicPacketCreatorTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
   for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
diff --git a/quic/core/quic_received_packet_manager_test.cc b/quic/core/quic_received_packet_manager_test.cc
index db5e260..9ce50dd 100644
--- a/quic/core/quic_received_packet_manager_test.cc
+++ b/quic/core/quic_received_packet_manager_test.cc
@@ -45,14 +45,14 @@
 struct TestParams {
   explicit TestParams(QuicTransportVersion version) : version(version) {}
 
-  friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
-    os << "{ version: " << QuicVersionToString(p.version) << " }";
-    return os;
-  }
-
   QuicTransportVersion version;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  return QuicVersionToString(p.version);
+}
+
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
   QuicTransportVersionVector all_supported_versions =
@@ -110,7 +110,8 @@
 
 INSTANTIATE_TEST_SUITE_P(QuicReceivedPacketManagerTest,
                          QuicReceivedPacketManagerTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicReceivedPacketManagerTest, DontWaitForPacketsBefore) {
   QuicPacketHeader header;
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 4f6412a..d5d47df 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -379,7 +379,10 @@
   StrictMock<MockSessionNotifier> notifier_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests, QuicSentPacketManagerTest, testing::Bool());
+INSTANTIATE_TEST_SUITE_P(Tests,
+                         QuicSentPacketManagerTest,
+                         ::testing::Bool(),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSentPacketManagerTest, IsUnacked) {
   VerifyUnackedPackets(nullptr, 0);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 60178fe..33f1396 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -509,7 +509,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSessionTestServer,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSessionTestServer, PeerAddress) {
   EXPECT_EQ(QuicSocketAddress(QuicIpAddress::Loopback4(), kTestPort),
@@ -1961,7 +1962,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSessionTestClient,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSessionTestClient, AvailableBidirectionalStreamsClient) {
   ASSERT_TRUE(session_.GetOrCreateStream(
@@ -2754,7 +2756,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSessionTestClientUnconfigured,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSessionTestClientUnconfigured, HoldMaxStreamsFrame) {
   if (!VersionHasIetfQuicFrames(transport_version())) {
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 67f20f4..7c1233b 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -189,7 +189,10 @@
       : QuicStreamIdManagerTestBase(Perspective::IS_CLIENT) {}
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests, QuicStreamIdManagerTestClient, testing::Bool());
+INSTANTIATE_TEST_SUITE_P(Tests,
+                         QuicStreamIdManagerTestClient,
+                         ::testing::Bool(),
+                         ::testing::PrintToStringParamName());
 
 // Check that the parameters used by the stream ID manager are properly
 // initialized.
@@ -721,7 +724,10 @@
   session_->OnConfigNegotiated();
 }
 
-INSTANTIATE_TEST_SUITE_P(Tests, QuicStreamIdManagerTestServer, testing::Bool());
+INSTANTIATE_TEST_SUITE_P(Tests,
+                         QuicStreamIdManagerTestServer,
+                         ::testing::Bool(),
+                         ::testing::PrintToStringParamName());
 
 // This test checks that the initialization for the maximum allowed outgoing
 // stream id is correct.
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 97863ad..54ba983 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -155,14 +155,16 @@
 INSTANTIATE_TEST_SUITE_P(
     QuicStreamTests,
     QuicStreamTest,
-    ::testing::ValuesIn(ParsedVersionOfIndex(AllSupportedVersions(), 1)));
+    ::testing::ValuesIn(ParsedVersionOfIndex(AllSupportedVersions(), 1)),
+    ::testing::PrintToStringParamName());
 
 // Make a parameterized version of the QuicStreamTest for those tests
 // that need to differentiate based on version number.
 class QuicParameterizedStreamTest : public QuicStreamTestBase {};
 INSTANTIATE_TEST_SUITE_P(QuicParameterizedStreamTests,
                          QuicParameterizedStreamTest,
-                         ::testing::ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicStreamTest, PendingStreamStaticness) {
   Initialize();
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index 5dda2ae..ad09639 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -29,17 +29,19 @@
       : perspective(perspective),
         session_decides_what_to_write(session_decides_what_to_write) {}
 
-  friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
-    os << "{ Perspective: " << p.perspective
-       << " session_decides_what_to_write: " << p.session_decides_what_to_write
-       << " }";
-    return os;
-  }
-
   Perspective perspective;
   bool session_decides_what_to_write;
 };
 
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  return QuicStrCat(
+      (p.perspective == Perspective::IS_CLIENT ? "Client" : "Server"),
+      "_Session",
+      (p.session_decides_what_to_write ? "Decides" : "DoesNotDecide"),
+      "WhatToWrite");
+}
+
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
   for (Perspective perspective :
@@ -200,7 +202,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicUnackedPacketMapTest,
-                         ::testing::ValuesIn(GetTestParams()));
+                         ::testing::ValuesIn(GetTestParams()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicUnackedPacketMapTest, RttOnly) {
   // Acks are only tracked for RTT measurement purposes.
diff --git a/quic/core/quic_write_blocked_list_test.cc b/quic/core/quic_write_blocked_list_test.cc
index 5d4b639..15494e2 100644
--- a/quic/core/quic_write_blocked_list_test.cc
+++ b/quic/core/quic_write_blocked_list_test.cc
@@ -32,7 +32,10 @@
   QuicWriteBlockedList write_blocked_list_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests, QuicWriteBlockedListTest, testing::Bool());
+INSTANTIATE_TEST_SUITE_P(Tests,
+                         QuicWriteBlockedListTest,
+                         ::testing::Bool(),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicWriteBlockedListTest, PriorityOrder) {
   if (GetParam()) {
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index 3362139..ef62bd8 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -107,7 +107,8 @@
 INSTANTIATE_TEST_SUITE_P(Tests,
                          UberQuicStreamIdManagerTest,
                          ::testing::ValuesIn({Perspective::IS_CLIENT,
-                                              Perspective::IS_SERVER}));
+                                              Perspective::IS_SERVER}),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(UberQuicStreamIdManagerTest, Initialization) {
   if (GetParam() == Perspective::IS_SERVER) {