diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 3b13e65..1339437 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -509,7 +509,8 @@
                                   Perspective perspective) {
   const QuicData& data = message.GetSerialized();
   QuicSession* session = QuicStreamPeer::session(stream);
-  if (session->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session->connection()->transport_version())) {
     QuicStreamFrame frame(QuicUtils::GetCryptoStreamId(
                               session->connection()->transport_version()),
                           false, stream->crypto_bytes_read(),
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index ca2d9ff..aca0a57 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -857,7 +857,7 @@
   QuicFrames frames;
   QuicFramer framer(*versions, QuicTime::Zero(), perspective,
                     kQuicDefaultConnectionIdLength);
-  if ((*versions)[0].transport_version < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames((*versions)[0].transport_version)) {
     QuicFrame frame(QuicStreamFrame(
         QuicUtils::GetCryptoStreamId((*versions)[0].transport_version), false,
         0, QuicStringPiece(data)));
diff --git a/quic/test_tools/simple_session_notifier.cc b/quic/test_tools/simple_session_notifier.cc
index c56831e..d1ee832 100644
--- a/quic/test_tools/simple_session_notifier.cc
+++ b/quic/test_tools/simple_session_notifier.cc
@@ -386,7 +386,7 @@
 }
 
 bool SimpleSessionNotifier::HasUnackedCryptoData() const {
-  if (connection_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
       const StreamState& state = crypto_state_[i];
       if (state.bytes_total > state.bytes_sent) {
