Removing QUIC's VERSION_6, now that QUIC no longer needs to support the

net/quic/quic_connection_test.cc

 // Copyright (c) 2012 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 "net/quic/quic_connection.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
@@ skipping 2355 matching lines @@
   EXPECT_TRUE(NULL != packet.get());
   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
       ENCRYPTION_NONE, 1, *packet));
 
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_PEER_GOING_AWAY, true));
   EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(0);
 
   connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
 }
 
-// The QUIC_VERSION_X versions are deliberately set, rather than using all
-// values in kSupportedQuicVersions.
 TEST_F(QuicConnectionTest, SelectMutualVersion) {
-  // Set the connection to speak QUIC_VERSION_6.
-  connection_.set_version(QUIC_VERSION_6);
-  EXPECT_EQ(connection_.version(), QUIC_VERSION_6);
+  // Set the connection to speak the lowest quic version.
+  connection_.set_version(QuicVersionMin());
+  EXPECT_EQ(QuicVersionMin(), connection_.version());
 
   // Pass in available versions which includes a higher mutually supported
   // version.  The higher mutually supported version should be selected.
-  QuicVersionVector available_versions;
-  available_versions.push_back(QUIC_VERSION_6);
-  available_versions.push_back(QUIC_VERSION_7);
-  EXPECT_TRUE(connection_.SelectMutualVersion(available_versions));
-  EXPECT_EQ(connection_.version(), QUIC_VERSION_7);
+  QuicVersionVector supported_versions;
+  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
+    supported_versions.push_back(kSupportedQuicVersions[i]);
+  }
+  EXPECT_TRUE(connection_.SelectMutualVersion(supported_versions));
+  EXPECT_EQ(QuicVersionMax(), connection_.version());
 
-  // Expect that the lower version is selected.
-  QuicVersionVector lower_version;
-  lower_version.push_back(QUIC_VERSION_6);
-  EXPECT_TRUE(connection_.SelectMutualVersion(lower_version));
-  EXPECT_EQ(connection_.version(), QUIC_VERSION_6);
+  // Expect that the lowest version is selected.
+  // Ensure the lowest supported version is less than the max, unless they're
+  // the same.
+  EXPECT_LE(QuicVersionMin(), QuicVersionMax());
+  QuicVersionVector lowest_version_vector;
+  lowest_version_vector.push_back(QuicVersionMin());
+  EXPECT_TRUE(connection_.SelectMutualVersion(lowest_version_vector));
+  EXPECT_EQ(QuicVersionMin(), connection_.version());
 
   // Shouldn't be able to find a mutually supported version.
   QuicVersionVector unsupported_version;
   unsupported_version.push_back(QUIC_VERSION_UNSUPPORTED);
   EXPECT_FALSE(connection_.SelectMutualVersion(unsupported_version));
 }
 
 TEST_F(QuicConnectionTest, ConnectionCloseWhenNotWriteBlocked) {
   helper_->set_blocked(false);  // Already default.
 
@@ skipping 28 matching lines @@
 
   // Send an erroneous packet to close the connection.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_PACKET_HEADER, false));
   ProcessDataPacket(6000, 0, !kEntropyFlag);
   EXPECT_EQ(1u, helper_->packets_write_attempts());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net