diff --git a/quic/api/test/QuicTransportTest.cpp b/quic/api/test/QuicTransportTest.cpp
index 1eb8bdd2e..9cfda0714 100644
--- a/quic/api/test/QuicTransportTest.cpp
+++ b/quic/api/test/QuicTransportTest.cpp
@@ -1026,7 +1026,22 @@ TEST_F(QuicTransportTest, ClonePathChallenge) {
   auto numPathChallengePackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<PathChallengeFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](PathChallengeFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numPathChallengePackets, 1);
 
   // Force a timeout with no data so that it clones the packet
@@ -1036,8 +1051,22 @@ TEST_F(QuicTransportTest, ClonePathChallenge) {
   numPathChallengePackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<PathChallengeFrame>());
-
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](PathChallengeFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numPathChallengePackets, 3);
 }
 
@@ -1059,7 +1088,22 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
   auto numPathChallengePackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<PathChallengeFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](PathChallengeFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numPathChallengePackets, 1);
 
   // Reset outstandingPathValidation
@@ -1072,7 +1116,22 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
   numPathChallengePackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<PathChallengeFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](PathChallengeFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numPathChallengePackets, 1);
 }
 
@@ -1197,7 +1256,22 @@ TEST_F(QuicTransportTest, ClonePathResponse) {
   auto numPathResponsePackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<PathResponseFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](PathResponseFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numPathResponsePackets, 1);
 
   // Force a timeout with no data so that it clones the packet
@@ -1205,7 +1279,22 @@ TEST_F(QuicTransportTest, ClonePathResponse) {
   numPathResponsePackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<PathResponseFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](PathResponseFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numPathResponsePackets, 1);
 }
 
@@ -1276,7 +1365,22 @@ TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) {
   auto numNewConnIdPackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<NewConnectionIdFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](NewConnectionIdFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numNewConnIdPackets, 1);
 
   // Force a timeout with no data so that it clones the packet
@@ -1286,7 +1390,22 @@ TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) {
   numNewConnIdPackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<NewConnectionIdFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](NewConnectionIdFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numNewConnIdPackets, 3);
 }
 
@@ -1410,7 +1529,22 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
   auto numRetireConnIdPackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<RetireConnectionIdFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](RetireConnectionIdFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numRetireConnIdPackets, 1);
 
   // Force a timeout with no data so that it clones the packet
@@ -1420,7 +1554,22 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
   numRetireConnIdPackets = std::count_if(
       conn.outstandingPackets.begin(),
       conn.outstandingPackets.end(),
-      findFrameInPacketFunc<RetireConnectionIdFrame>());
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](RetireConnectionIdFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_EQ(numRetireConnIdPackets, 3);
 }
 
diff --git a/quic/common/test/TestUtils.h b/quic/common/test/TestUtils.h
index 1a1259d28..78630d3ab 100644
--- a/quic/common/test/TestUtils.h
+++ b/quic/common/test/TestUtils.h
@@ -275,23 +275,5 @@ std::vector<int> getQLogEventIndices(
     QLogEventType type,
     const std::shared_ptr<FileQLogger>& q);
 
-template <typename FrameType>
-auto findFrameInPacketFunc() {
-  return [&](auto& p) {
-    return std::find_if(
-               p.packet.frames.begin(), p.packet.frames.end(), [&](auto& f) {
-                 return folly::variant_match(
-                     f,
-                     [&](QuicSimpleFrame& s) {
-                       return folly::variant_match(
-                           s,
-                           [&](FrameType&) { return true; },
-                           [&](auto&) { return false; });
-                     },
-                     [&](auto&) { return false; });
-               }) != p.packet.frames.end();
-  };
-}
-
 } // namespace test
 } // namespace quic
diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp
index a635d3c9b..1b2bbb1db 100644
--- a/quic/server/test/QuicServerTransportTest.cpp
+++ b/quic/server/test/QuicServerTransportTest.cpp
@@ -1585,8 +1585,22 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) {
   auto packetItr = std::find_if(
       server->getNonConstConn().outstandingPackets.begin(),
       server->getNonConstConn().outstandingPackets.end(),
-      findFrameInPacketFunc<StopSendingFrame>());
-
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](StopSendingFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   ASSERT_TRUE(packetItr != server->getNonConstConn().outstandingPackets.end());
   // Force a timeout with no data so that it clones the packet
   server->lossTimeout().timeoutExpired();
@@ -1594,8 +1608,22 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) {
   auto numStopSendingPackets = std::count_if(
       server->getNonConstConn().outstandingPackets.begin(),
       server->getNonConstConn().outstandingPackets.end(),
-      findFrameInPacketFunc<StopSendingFrame>());
-
+      [&](auto& p) {
+        return std::find_if(
+                   p.packet.frames.begin(),
+                   p.packet.frames.end(),
+                   [&](auto& f) {
+                     return folly::variant_match(
+                         f,
+                         [&](QuicSimpleFrame& s) {
+                           return folly::variant_match(
+                               s,
+                               [&](StopSendingFrame&) { return true; },
+                               [&](auto&) { return false; });
+                         },
+                         [&](auto&) { return false; });
+                   }) != p.packet.frames.end();
+      });
   EXPECT_GT(numStopSendingPackets, 1);
 
   std::vector<int> indices =
@@ -1611,8 +1639,22 @@ TEST_F(QuicServerTransportTest, TestAckStopSending) {
   server->getNonConstConn().streamManager->getStream(streamId);
   server->stopSending(streamId, GenericApplicationErrorCode::UNKNOWN);
   loopForWrites();
-  auto match = findFrameInPacketFunc<StopSendingFrame>();
-
+  auto match = [](OutstandingPacket& packet) {
+    return std::find_if(
+               packet.packet.frames.begin(),
+               packet.packet.frames.end(),
+               [&](auto& f) {
+                 return folly::variant_match(
+                     f,
+                     [&](QuicSimpleFrame& s) {
+                       return folly::variant_match(
+                           s,
+                           [&](StopSendingFrame&) { return true; },
+                           [&](auto&) { return false; });
+                     },
+                     [&](auto&) { return false; });
+               }) != packet.packet.frames.end();
+  };
   auto op = findOutstandingPacket(server->getNonConstConn(), match);
   ASSERT_TRUE(op != nullptr);
   PacketNum packetNum = op->packet.header.getPacketSequenceNum();