diff --git a/quiche/common/wire_serialization_test.cc b/quiche/common/wire_serialization_test.cc
index 6c8267f..37216ca 100644
--- a/quiche/common/wire_serialization_test.cc
+++ b/quiche/common/wire_serialization_test.cc
@@ -238,17 +238,18 @@
 
 TEST(SerializationTest, CustomStructWritesTooLittle) {
   constexpr absl::string_view kStr = "\xaa\xbb\xcc\xdd";
+  absl::Status status;
 #if defined(NDEBUG)
-  absl::Status status =
-      SerializeIntoSimpleBuffer(WireFormatterThatWritesTooLittle(kStr))
-          .status();
+  status = SerializeIntoSimpleBuffer(WireFormatterThatWritesTooLittle(kStr))
+               .status();
   EXPECT_THAT(status, StatusIs(absl::StatusCode::kInternal,
                                ::testing::HasSubstr("Excess 1 bytes")));
 #else
-  EXPECT_DEATH(QUICHE_LOG(INFO) << SerializeIntoSimpleBuffer(
-                                       WireFormatterThatWritesTooLittle(kStr))
-                                       .status(),
-               "while serializing field #0");
+  EXPECT_QUICHE_DEBUG_DEATH(
+      status = SerializeIntoSimpleBuffer(WireFormatterThatWritesTooLittle(kStr))
+                   .status(),
+      "while serializing field #0");
+  EXPECT_THAT(status, StatusIs(absl::StatusCode::kOk));
 #endif
 }
 
diff --git a/quiche/quic/core/deterministic_connection_id_generator_test.cc b/quiche/quic/core/deterministic_connection_id_generator_test.cc
index a24b3dc..47195cc 100644
--- a/quiche/quic/core/deterministic_connection_id_generator_test.cc
+++ b/quiche/quic/core/deterministic_connection_id_generator_test.cc
@@ -11,6 +11,7 @@
 
 namespace quic {
 namespace test {
+namespace {
 
 struct TestParams {
   TestParams(int connection_id_length)
@@ -122,5 +123,6 @@
   EXPECT_EQ(generator_.ConnectionIdLength(0x01), connection_id_length_);
 }
 
+}  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quiche/quic/core/quic_generic_session.h b/quiche/quic/core/quic_generic_session.h
index 48d02f3..384f0a3 100644
--- a/quiche/quic/core/quic_generic_session.h
+++ b/quiche/quic/core/quic_generic_session.h
@@ -33,7 +33,7 @@
 class QuicGenericStream;
 
 // Returns QUIC versions to be used with QuicGenericSessionBase.
-ParsedQuicVersionVector GetQuicVersionsForGenericSession();
+QUICHE_EXPORT ParsedQuicVersionVector GetQuicVersionsForGenericSession();
 
 using CreateWebTransportSessionVisitorCallback =
     quiche::UnretainedCallback<std::unique_ptr<webtransport::SessionVisitor>(
diff --git a/quiche/quic/core/tls_server_handshaker_test.cc b/quiche/quic/core/tls_server_handshaker_test.cc
index 9e4eb9d..8801cb2 100644
--- a/quiche/quic/core/tls_server_handshaker_test.cc
+++ b/quiche/quic/core/tls_server_handshaker_test.cc
@@ -1194,13 +1194,13 @@
       {false, false},
       {true, true},
   };
-  for (size_t i = 0; i < arraysize(tests); i++) {
+  for (size_t i = 0; i < ABSL_ARRAYSIZE(tests); i++) {
     SCOPED_TRACE(absl::StrCat("Test #", i));
     const auto& test = tests[i];
     client_crypto_config_->set_alps_use_new_codepoint(
         test.client_use_alps_new_codepoint);
-    absl::SetFlag(&FLAGS_gfe2_reloadable_flag_quic_gfe_allow_alps_new_codepoint,
-                  test.server_allow_alps_new_codepoint);
+    SetQuicReloadableFlag(quic_gfe_allow_alps_new_codepoint,
+                          test.server_allow_alps_new_codepoint);
 
     ASSERT_TRUE(SetupClientCert());
     InitializeFakeClient();
diff --git a/quiche/quic/tools/connect_udp_tunnel_test.cc b/quiche/quic/tools/connect_udp_tunnel_test.cc
index 9df94a9..d86ff0c 100644
--- a/quiche/quic/tools/connect_udp_tunnel_test.cc
+++ b/quiche/quic/tools/connect_udp_tunnel_test.cc
@@ -25,6 +25,7 @@
 #include "quiche/common/platform/api/quiche_googleurl.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
 #include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/platform/api/quiche_url_utils.h"
 
 namespace quic::test {
 namespace {
@@ -213,14 +214,6 @@
   EXPECT_FALSE(tunnel_.IsTunnelOpenToTarget());
 }
 
-std::string PercentEncode(absl::string_view input) {
-  std::string encoded;
-  url::StdStringCanonOutput canon_output(&encoded);
-  url::EncodeURIComponent(input.data(), input.size(), &canon_output);
-  canon_output.Complete();
-  return encoded;
-}
-
 TEST_F(ConnectUdpTunnelTest, OpenTunnelToIpv6LiteralTarget) {
   EXPECT_CALL(*socket_, ConnectBlocking()).WillOnce(Return(absl::OkStatus()));
   EXPECT_CALL(*socket_, ReceiveAsync(Gt(0)));
@@ -239,15 +232,19 @@
                 Property(&QuicBackendResponse::trailers, IsEmpty()),
                 Property(&QuicBackendResponse::body, IsEmpty()))));
 
+  std::string path;
+  ASSERT_TRUE(quiche::ExpandURITemplate(
+      "/.well-known/masque/udp/{target_host}/{target_port}/",
+      {{"target_host", absl::StrCat("[", TestLoopback6().ToString(), "]")},
+       {"target_port", absl::StrCat(kAcceptablePort)}},
+      &path));
+
   spdy::Http2HeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
   request_headers[":scheme"] = "https";
-  request_headers[":path"] = absl::StrCat(
-      "/.well-known/masque/udp/",
-      PercentEncode(absl::StrCat("[", TestLoopback6().ToString(), "]")), "/",
-      kAcceptablePort, "/");
+  request_headers[":path"] = path;
 
   tunnel_.OpenTunnel(request_headers);
   EXPECT_TRUE(tunnel_.IsTunnelOpenToTarget());