diff --git a/quic/core/crypto/transport_parameters_test.cc b/quic/core/crypto/transport_parameters_test.cc
index 3991953..d47ffa3 100644
--- a/quic/core/crypto/transport_parameters_test.cc
+++ b/quic/core/crypto/transport_parameters_test.cc
@@ -26,20 +26,13 @@
 const QuicVersionLabel kFakeVersionLabel = 0x01234567;
 const QuicVersionLabel kFakeVersionLabel2 = 0x89ABCDEF;
 const uint64_t kFakeIdleTimeoutMilliseconds = 12012;
-const uint8_t kFakeStatelessResetTokenData[16] = {
-    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
-    0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F};
-const uint64_t kFakeMaxPacketSize = 9001;
 const uint64_t kFakeInitialMaxData = 101;
 const uint64_t kFakeInitialMaxStreamDataBidiLocal = 2001;
 const uint64_t kFakeInitialMaxStreamDataBidiRemote = 2002;
 const uint64_t kFakeInitialMaxStreamDataUni = 3000;
 const uint64_t kFakeInitialMaxStreamsBidi = 21;
 const uint64_t kFakeInitialMaxStreamsUni = 22;
-const uint64_t kFakeAckDelayExponent = 10;
-const uint64_t kFakeMaxAckDelay = 51;
 const bool kFakeDisableMigration = true;
-const uint64_t kFakeActiveConnectionIdLimit = 52;
 const uint64_t kFakeInitialRoundTripTime = 53;
 const uint8_t kFakePreferredStatelessResetTokenData[16] = {
     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
@@ -69,12 +62,6 @@
   return TestConnectionId(0xBEEF);
 }
 
-std::vector<uint8_t> CreateFakeStatelessResetToken() {
-  return std::vector<uint8_t>(
-      kFakeStatelessResetTokenData,
-      kFakeStatelessResetTokenData + sizeof(kFakeStatelessResetTokenData));
-}
-
 std::vector<uint8_t> CreateFakePreferredStatelessResetToken() {
   return std::vector<uint8_t>(
       kFakePreferredStatelessResetTokenData,
@@ -174,19 +161,19 @@
   EXPECT_TRUE(orig_params != new_params);
   new_params.supported_versions.pop_back();
   new_params.supported_versions.push_back(kFakeVersionLabel);
-  orig_params.stateless_reset_token = CreateFakeStatelessResetToken();
-  new_params.stateless_reset_token = CreateFakeStatelessResetToken();
+  orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
+  new_params.stateless_reset_token = CreateStatelessResetTokenForTest();
   EXPECT_EQ(orig_params, new_params);
   EXPECT_TRUE(orig_params == new_params);
   EXPECT_FALSE(orig_params != new_params);
 
   // Test comparison on IntegerParameters.
-  orig_params.max_udp_payload_size.set_value(kFakeMaxPacketSize);
-  new_params.max_udp_payload_size.set_value(kFakeMaxPacketSize + 1);
+  orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
+  new_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest + 1);
   EXPECT_NE(orig_params, new_params);
   EXPECT_FALSE(orig_params == new_params);
   EXPECT_TRUE(orig_params != new_params);
-  new_params.max_udp_payload_size.set_value(kFakeMaxPacketSize);
+  new_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
   EXPECT_EQ(orig_params, new_params);
   EXPECT_TRUE(orig_params == new_params);
   EXPECT_FALSE(orig_params != new_params);
@@ -259,8 +246,8 @@
   orig_params.original_destination_connection_id =
       CreateFakeOriginalDestinationConnectionId();
   orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
-  orig_params.stateless_reset_token = CreateFakeStatelessResetToken();
-  orig_params.max_udp_payload_size.set_value(kFakeMaxPacketSize);
+  orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
+  orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
   orig_params.initial_max_data.set_value(kFakeInitialMaxData);
   orig_params.initial_max_stream_data_bidi_local.set_value(
       kFakeInitialMaxStreamDataBidiLocal);
@@ -270,12 +257,12 @@
       kFakeInitialMaxStreamDataUni);
   orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
   orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
-  orig_params.ack_delay_exponent.set_value(kFakeAckDelayExponent);
-  orig_params.max_ack_delay.set_value(kFakeMaxAckDelay);
+  orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
+  orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
   orig_params.disable_active_migration = kFakeDisableMigration;
   orig_params.preferred_address = CreateFakePreferredAddress();
   orig_params.active_connection_id_limit.set_value(
-      kFakeActiveConnectionIdLimit);
+      kActiveConnectionIdLimitForTest);
   orig_params.initial_source_connection_id =
       CreateFakeInitialSourceConnectionId();
   orig_params.retry_source_connection_id = CreateFakeRetrySourceConnectionId();
@@ -295,7 +282,7 @@
   orig_params.perspective = Perspective::IS_CLIENT;
   orig_params.version = kFakeVersionLabel;
   orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
-  orig_params.max_udp_payload_size.set_value(kFakeMaxPacketSize);
+  orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
   orig_params.initial_max_data.set_value(kFakeInitialMaxData);
   orig_params.initial_max_stream_data_bidi_local.set_value(
       kFakeInitialMaxStreamDataBidiLocal);
@@ -305,11 +292,11 @@
       kFakeInitialMaxStreamDataUni);
   orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
   orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
-  orig_params.ack_delay_exponent.set_value(kFakeAckDelayExponent);
-  orig_params.max_ack_delay.set_value(kFakeMaxAckDelay);
+  orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
+  orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
   orig_params.disable_active_migration = kFakeDisableMigration;
   orig_params.active_connection_id_limit.set_value(
-      kFakeActiveConnectionIdLimit);
+      kActiveConnectionIdLimitForTest);
   orig_params.initial_source_connection_id =
       CreateFakeInitialSourceConnectionId();
   orig_params.initial_round_trip_time_us.set_value(kFakeInitialRoundTripTime);
@@ -342,8 +329,8 @@
   orig_params.original_destination_connection_id =
       CreateFakeOriginalDestinationConnectionId();
   orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
-  orig_params.stateless_reset_token = CreateFakeStatelessResetToken();
-  orig_params.max_udp_payload_size.set_value(kFakeMaxPacketSize);
+  orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
+  orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
   orig_params.initial_max_data.set_value(kFakeInitialMaxData);
   orig_params.initial_max_stream_data_bidi_local.set_value(
       kFakeInitialMaxStreamDataBidiLocal);
@@ -353,12 +340,12 @@
       kFakeInitialMaxStreamDataUni);
   orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
   orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
-  orig_params.ack_delay_exponent.set_value(kFakeAckDelayExponent);
-  orig_params.max_ack_delay.set_value(kFakeMaxAckDelay);
+  orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
+  orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
   orig_params.disable_active_migration = kFakeDisableMigration;
   orig_params.preferred_address = CreateFakePreferredAddress();
   orig_params.active_connection_id_limit.set_value(
-      kFakeActiveConnectionIdLimit);
+      kActiveConnectionIdLimitForTest);
   orig_params.initial_source_connection_id =
       CreateFakeInitialSourceConnectionId();
   orig_params.retry_source_connection_id = CreateFakeRetrySourceConnectionId();
@@ -475,8 +462,8 @@
   orig_params.perspective = Perspective::IS_CLIENT;
   orig_params.version = kFakeVersionLabel;
   orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
-  orig_params.stateless_reset_token = CreateFakeStatelessResetToken();
-  orig_params.max_udp_payload_size.set_value(kFakeMaxPacketSize);
+  orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
+  orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
 
   std::vector<uint8_t> out;
   bool ok;
@@ -660,7 +647,7 @@
   EXPECT_EQ(kFakeIdleTimeoutMilliseconds,
             new_params.max_idle_timeout_ms.value());
   EXPECT_TRUE(new_params.stateless_reset_token.empty());
-  EXPECT_EQ(kFakeMaxPacketSize, new_params.max_udp_payload_size.value());
+  EXPECT_EQ(kMaxPacketSizeForTest, new_params.max_udp_payload_size.value());
   EXPECT_EQ(kFakeInitialMaxData, new_params.initial_max_data.value());
   EXPECT_EQ(kFakeInitialMaxStreamDataBidiLocal,
             new_params.initial_max_stream_data_bidi_local.value());
@@ -672,10 +659,10 @@
             new_params.initial_max_streams_bidi.value());
   EXPECT_EQ(kFakeInitialMaxStreamsUni,
             new_params.initial_max_streams_uni.value());
-  EXPECT_EQ(kFakeAckDelayExponent, new_params.ack_delay_exponent.value());
-  EXPECT_EQ(kFakeMaxAckDelay, new_params.max_ack_delay.value());
+  EXPECT_EQ(kAckDelayExponentForTest, new_params.ack_delay_exponent.value());
+  EXPECT_EQ(kMaxAckDelayForTest, new_params.max_ack_delay.value());
   EXPECT_EQ(kFakeDisableMigration, new_params.disable_active_migration);
-  EXPECT_EQ(kFakeActiveConnectionIdLimit,
+  EXPECT_EQ(kActiveConnectionIdLimitForTest,
             new_params.active_connection_id_limit.value());
   ASSERT_TRUE(new_params.initial_source_connection_id.has_value());
   EXPECT_EQ(CreateFakeInitialSourceConnectionId(),
@@ -1069,8 +1056,9 @@
             new_params.original_destination_connection_id.value());
   EXPECT_EQ(kFakeIdleTimeoutMilliseconds,
             new_params.max_idle_timeout_ms.value());
-  EXPECT_EQ(CreateFakeStatelessResetToken(), new_params.stateless_reset_token);
-  EXPECT_EQ(kFakeMaxPacketSize, new_params.max_udp_payload_size.value());
+  EXPECT_EQ(CreateStatelessResetTokenForTest(),
+            new_params.stateless_reset_token);
+  EXPECT_EQ(kMaxPacketSizeForTest, new_params.max_udp_payload_size.value());
   EXPECT_EQ(kFakeInitialMaxData, new_params.initial_max_data.value());
   EXPECT_EQ(kFakeInitialMaxStreamDataBidiLocal,
             new_params.initial_max_stream_data_bidi_local.value());
@@ -1082,8 +1070,8 @@
             new_params.initial_max_streams_bidi.value());
   EXPECT_EQ(kFakeInitialMaxStreamsUni,
             new_params.initial_max_streams_uni.value());
-  EXPECT_EQ(kFakeAckDelayExponent, new_params.ack_delay_exponent.value());
-  EXPECT_EQ(kFakeMaxAckDelay, new_params.max_ack_delay.value());
+  EXPECT_EQ(kAckDelayExponentForTest, new_params.ack_delay_exponent.value());
+  EXPECT_EQ(kMaxAckDelayForTest, new_params.max_ack_delay.value());
   EXPECT_EQ(kFakeDisableMigration, new_params.disable_active_migration);
   ASSERT_NE(nullptr, new_params.preferred_address.get());
   EXPECT_EQ(CreateFakeV4SocketAddress(),
@@ -1094,7 +1082,7 @@
             new_params.preferred_address->connection_id);
   EXPECT_EQ(CreateFakePreferredStatelessResetToken(),
             new_params.preferred_address->stateless_reset_token);
-  EXPECT_EQ(kFakeActiveConnectionIdLimit,
+  EXPECT_EQ(kActiveConnectionIdLimitForTest,
             new_params.active_connection_id_limit.value());
   ASSERT_TRUE(new_params.initial_source_connection_id.has_value());
   EXPECT_EQ(CreateFakeInitialSourceConnectionId(),
@@ -1224,7 +1212,7 @@
   TransportParameters orig_params;
   orig_params.perspective = Perspective::IS_CLIENT;
   orig_params.version = kFakeVersionLabel;
-  orig_params.max_udp_payload_size.set_value(kFakeMaxPacketSize);
+  orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
 
   orig_params.google_quic_params = std::make_unique<CryptoHandshakeMessage>();
   const std::string kTestString = "test string";
@@ -1253,7 +1241,7 @@
               IsQuicNoError());
   EXPECT_EQ(test_value, kTestValue);
   EXPECT_EQ(kFakeVersionLabel, new_params.version);
-  EXPECT_EQ(kFakeMaxPacketSize, new_params.max_udp_payload_size.value());
+  EXPECT_EQ(kMaxPacketSizeForTest, new_params.max_udp_payload_size.value());
 }
 
 TEST_P(TransportParametersTest, VeryLongCustomParameter) {
@@ -1294,8 +1282,8 @@
         CreateFakeOriginalDestinationConnectionId();
     original_params_.max_idle_timeout_ms.set_value(
         kFakeIdleTimeoutMilliseconds);
-    original_params_.stateless_reset_token = CreateFakeStatelessResetToken();
-    original_params_.max_udp_payload_size.set_value(kFakeMaxPacketSize);
+    original_params_.stateless_reset_token = CreateStatelessResetTokenForTest();
+    original_params_.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
     original_params_.initial_max_data.set_value(kFakeInitialMaxData);
     original_params_.initial_max_stream_data_bidi_local.set_value(
         kFakeInitialMaxStreamDataBidiLocal);
@@ -1307,12 +1295,12 @@
         kFakeInitialMaxStreamsBidi);
     original_params_.initial_max_streams_uni.set_value(
         kFakeInitialMaxStreamsUni);
-    original_params_.ack_delay_exponent.set_value(kFakeAckDelayExponent);
-    original_params_.max_ack_delay.set_value(kFakeMaxAckDelay);
+    original_params_.ack_delay_exponent.set_value(kAckDelayExponentForTest);
+    original_params_.max_ack_delay.set_value(kMaxAckDelayForTest);
     original_params_.disable_active_migration = kFakeDisableMigration;
     original_params_.preferred_address = CreateFakePreferredAddress();
     original_params_.active_connection_id_limit.set_value(
-        kFakeActiveConnectionIdLimit);
+        kActiveConnectionIdLimitForTest);
     original_params_.initial_source_connection_id =
         CreateFakeInitialSourceConnectionId();
     original_params_.retry_source_connection_id =
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index 050a091..41dd2f8 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -22,23 +22,6 @@
 namespace test {
 namespace {
 
-constexpr uint32_t kMaxPacketSizeForTest = 1234;
-constexpr uint32_t kMaxDatagramFrameSizeForTest = 1333;
-constexpr uint8_t kFakeStatelessResetTokenData[16] = {
-    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
-    0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F};
-constexpr uint64_t kFakeAckDelayExponent = 10;
-constexpr uint64_t kFakeMaxAckDelay = 51;
-constexpr uint64_t kFakeActiveConnectionIdLimit = 52;
-
-// TODO(b/153726130): Consider merging this with methods in
-// transport_parameters_test.cc.
-std::vector<uint8_t> CreateFakeStatelessResetToken() {
-  return std::vector<uint8_t>(
-      kFakeStatelessResetTokenData,
-      kFakeStatelessResetTokenData + sizeof(kFakeStatelessResetTokenData));
-}
-
 class QuicConfigTest : public QuicTestWithParam<ParsedQuicVersion> {
  public:
   QuicConfigTest() : version_(GetParam()) {}
@@ -458,7 +441,7 @@
       4 * kMinimumFlowControlSendWindow);
   config_.SetMaxPacketSizeToSend(kMaxPacketSizeForTest);
   config_.SetMaxDatagramFrameSizeToSend(kMaxDatagramFrameSizeForTest);
-  config_.SetActiveConnectionIdLimitToSend(kFakeActiveConnectionIdLimit);
+  config_.SetActiveConnectionIdLimitToSend(kActiveConnectionIdLimitForTest);
 
   config_.SetOriginalConnectionIdToSend(TestConnectionId(0x1111));
   config_.SetInitialSourceConnectionIdToSend(TestConnectionId(0x2222));
@@ -480,7 +463,7 @@
   EXPECT_EQ(kMaxPacketSizeForTest, params.max_udp_payload_size.value());
   EXPECT_EQ(kMaxDatagramFrameSizeForTest,
             params.max_datagram_frame_size.value());
-  EXPECT_EQ(kFakeActiveConnectionIdLimit,
+  EXPECT_EQ(kActiveConnectionIdLimitForTest,
             params.active_connection_id_limit.value());
 
   ASSERT_TRUE(params.original_destination_connection_id.has_value());
@@ -510,10 +493,10 @@
   params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
   params.max_datagram_frame_size.set_value(kMaxDatagramFrameSizeForTest);
   params.initial_max_streams_bidi.set_value(kDefaultMaxStreamsPerConnection);
-  params.stateless_reset_token = CreateFakeStatelessResetToken();
-  params.max_ack_delay.set_value(kFakeMaxAckDelay);
-  params.ack_delay_exponent.set_value(kFakeAckDelayExponent);
-  params.active_connection_id_limit.set_value(kFakeActiveConnectionIdLimit);
+  params.stateless_reset_token = CreateStatelessResetTokenForTest();
+  params.max_ack_delay.set_value(kMaxAckDelayForTest);
+  params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
+  params.active_connection_id_limit.set_value(kActiveConnectionIdLimitForTest);
   params.original_destination_connection_id = TestConnectionId(0x1111);
   params.initial_source_connection_id = TestConnectionId(0x2222);
   params.retry_source_connection_id = TestConnectionId(0x3333);
@@ -615,14 +598,14 @@
 
   ASSERT_TRUE(config_.HasReceivedStatelessResetToken());
   ASSERT_TRUE(config_.HasReceivedMaxAckDelayMs());
-  EXPECT_EQ(config_.ReceivedMaxAckDelayMs(), kFakeMaxAckDelay);
+  EXPECT_EQ(config_.ReceivedMaxAckDelayMs(), kMaxAckDelayForTest);
 
   ASSERT_TRUE(config_.HasReceivedAckDelayExponent());
-  EXPECT_EQ(config_.ReceivedAckDelayExponent(), kFakeAckDelayExponent);
+  EXPECT_EQ(config_.ReceivedAckDelayExponent(), kAckDelayExponentForTest);
 
   ASSERT_TRUE(config_.HasReceivedActiveConnectionIdLimit());
   EXPECT_EQ(config_.ReceivedActiveConnectionIdLimit(),
-            kFakeActiveConnectionIdLimit);
+            kActiveConnectionIdLimitForTest);
 
   ASSERT_TRUE(config_.HasReceivedOriginalConnectionId());
   EXPECT_EQ(config_.ReceivedOriginalConnectionId(), TestConnectionId(0x1111));
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 41fb995..0dba17b 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -77,6 +77,15 @@
   return quiche::QuicheEndian::NetToHost64(connection_id64_net);
 }
 
+std::vector<uint8_t> CreateStatelessResetTokenForTest() {
+  static constexpr uint8_t kStatelessResetTokenDataForTest[16] = {
+      0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+      0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F};
+  return std::vector<uint8_t>(kStatelessResetTokenDataForTest,
+                              kStatelessResetTokenDataForTest +
+                                  sizeof(kStatelessResetTokenDataForTest));
+}
+
 std::string TestHostname() {
   return "test.example.org";
 }
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 2af8aeb..5ad5575 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -55,10 +55,21 @@
 
 enum : uint16_t { kTestPort = 12345 };
 enum : uint32_t {
+  kMaxDatagramFrameSizeForTest = 1333,
+  kMaxPacketSizeForTest = 9001,
   kInitialStreamFlowControlWindowForTest = 1024 * 1024,   // 1 MB
   kInitialSessionFlowControlWindowForTest = 1536 * 1024,  // 1.5 MB
 };
 
+enum : uint64_t {
+  kAckDelayExponentForTest = 10,
+  kMaxAckDelayForTest = 51,
+  kActiveConnectionIdLimitForTest = 52,
+};
+
+// Create an arbitrary stateless reset token, same across multiple calls.
+std::vector<uint8_t> CreateStatelessResetTokenForTest();
+
 // A hostname useful for testing, returns "test.example.org".
 std::string TestHostname();