Fix crypto_server_test to pass with lower supported versions, and parameterize the tests by version.

net/quic/crypto/crypto_server_test.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <ostream>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/secure_hash.h"
@@ skipping 30 matching lines @@
     return &server_config_->strike_register_client_lock_;
   }
 
  private:
   QuicCryptoServerConfig* server_config_;
 };
 
 // Run tests with both parities of
 // FLAGS_use_early_return_when_verifying_chlo.
 struct TestParams {
-  explicit TestParams(bool use_early_return_when_verifying_chlo,
-                      bool enable_stateless_rejects,
-                      bool use_stateless_rejects)
+  TestParams(bool use_early_return_when_verifying_chlo,
+             bool enable_stateless_rejects,
+             bool use_stateless_rejects,
+             QuicVersionVector supported_versions)
       : use_early_return_when_verifying_chlo(
             use_early_return_when_verifying_chlo),
         enable_stateless_rejects(enable_stateless_rejects),
-        use_stateless_rejects(use_stateless_rejects) {}
+        use_stateless_rejects(use_stateless_rejects),
+        supported_versions(supported_versions) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ use_early_return_when_verifying_chlo: "
        << p.use_early_return_when_verifying_chlo << endl;
     os << "  enable_stateless_rejects: " << p.enable_stateless_rejects << endl;
-    os << "  use_stateless_rejects: " << p.use_stateless_rejects << " }";
+    os << "  use_stateless_rejects: " << p.use_stateless_rejects << endl;
+    os << "  versions: " << QuicVersionVectorToString(p.supported_versions)
+       << " }";
     return os;
   }
 
   bool use_early_return_when_verifying_chlo;
   // This only enables the stateless reject feature via the feature-flag.
   // It does not force the crypto server to emit stateless rejects.
   bool enable_stateless_rejects;
   // If true, this forces the server to send a stateless reject when
   // rejecting messages.  This should be a no-op if
   // enable_stateless_rejects is false.
   bool use_stateless_rejects;
+  // Versions supported by client and server.
+  QuicVersionVector supported_versions;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   static const bool kTrueFalse[] = {true, false};
   for (bool use_early_return : kTrueFalse) {
     for (bool enable_stateless_rejects : kTrueFalse) {
       for (bool use_stateless_rejects : kTrueFalse) {
-        params.push_back(TestParams(use_early_return, enable_stateless_rejects,
-                                    use_stateless_rejects));
+        // Start with all versions, remove highest on each iteration.
+        QuicVersionVector supported_versions = QuicSupportedVersions();
+        while (!supported_versions.empty()) {
+          params.push_back(
+              TestParams(use_early_return, enable_stateless_rejects,
+                         use_stateless_rejects, supported_versions));
+          supported_versions.erase(supported_versions.begin());
+        }
       }
     }
   }
   return params;
 }
 
 class CryptoServerTest : public ::testing::TestWithParam<TestParams> {
  public:
   CryptoServerTest()
       : rand_(QuicRandom::GetInstance()),
         client_address_(Loopback4(), 1234),
         config_(QuicCryptoServerConfig::TESTING, rand_) {
 #if defined(USE_OPENSSL)
     config_.SetProofSource(CryptoTestUtils::ProofSourceForTesting());
 #else
     config_.SetProofSource(CryptoTestUtils::FakeProofSourceForTesting());
 #endif
-    supported_versions_ = QuicSupportedVersions();
+    supported_versions_ = GetParam().supported_versions;
     client_version_ = supported_versions_.front();
     client_version_string_ =
         QuicUtils::TagToString(QuicVersionToQuicTag(client_version_));
 
     FLAGS_use_early_return_when_verifying_chlo =
         GetParam().use_early_return_when_verifying_chlo;
     FLAGS_enable_quic_stateless_reject_support =
         GetParam().enable_stateless_rejects;
     use_stateless_rejects_ = GetParam().use_stateless_rejects;
   }
@@ skipping 83 matching lines @@
     CryptoServerTest* test_;
     bool should_succeed_;
     const char* error_substr_;
     bool* called_;
   };
 
   void CheckServerHello(const CryptoHandshakeMessage& server_hello) {
     const QuicTag* versions;
     size_t num_versions;
     server_hello.GetTaglist(kVER, &versions, &num_versions);
-    ASSERT_EQ(QuicSupportedVersions().size(), num_versions);
+    ASSERT_EQ(supported_versions_.size(), num_versions);
     for (size_t i = 0; i < num_versions; ++i) {
-      EXPECT_EQ(QuicVersionToQuicTag(QuicSupportedVersions()[i]), versions[i]);
+      EXPECT_EQ(QuicVersionToQuicTag(supported_versions_[i]), versions[i]);
     }
 
     StringPiece address;
     ASSERT_TRUE(server_hello.GetStringPiece(kCADR, &address));
     QuicSocketAddressCoder decoder;
     ASSERT_TRUE(decoder.Decode(address.data(), address.size()));
     EXPECT_EQ(client_address_.address(), decoder.ip());
     EXPECT_EQ(client_address_.port(), decoder.port());
   }
 
@@ skipping 204 matching lines @@
       "$padding", static_cast<int>(kClientHelloMinimumSize),
       nullptr);
   // clang-format on
 
   ShouldSucceed(msg);
   StringPiece cert, proof;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_NE(0u, cert.size());
   EXPECT_NE(0u, proof.size());
-  if (client_version_ <= QUIC_VERSION_26) {
-    const HandshakeFailureReason kRejectReasons[] = {
-        CLIENT_NONCE_INVALID_TIME_FAILURE};
-    CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
-  } else {
-    const HandshakeFailureReason kRejectReasons[] = {
-        SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
-    CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
-  }
+  const HandshakeFailureReason kRejectReasons[] = {
+      SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
+  CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, TooSmall) {
   // clang-format off
   ShouldFailMentioning("too small", CryptoTestUtils::Message(
         "CHLO",
         "VER\0", client_version_string_.c_str(),
         nullptr));
   // clang-format on
   const HandshakeFailureReason kRejectReasons[] = {
@@ skipping 211 matching lines @@
   ASSERT_EQ(kSHLO, out_.tag());
   CheckServerHello(out_);
 
   ShouldSucceed(msg);
   // The message should accepted twice when replay protection is off.
   ASSERT_EQ(kSHLO, out_.tag());
   CheckServerHello(out_);
 }
 
 TEST_P(CryptoServerTest, RejectInvalidXlct) {
+  if (client_version_ <= QUIC_VERSION_25) {
+    // XLCT tag introduced in QUIC_VERSION_26.
+    return;
+  }
   // clang-format off
   CryptoHandshakeMessage msg = CryptoTestUtils::Message(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", scid_hex_.c_str(),
       "#004b5453", srct_hex_.c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", nonce_hex_.c_str(),
       "VER\0", client_version_string_.c_str(),
@@ skipping 286 matching lines @@
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   CheckRejectTag();
 }
 
 }  // namespace test
 }  // namespace net