Landing Recent QUIC changes until Sat Aug 13 04:32:36 2016 UTC-0

net/tools/quic/end_to_end_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 <stddef.h>
 #include <sys/epoll.h>
 
 #include <list>
 #include <memory>
 #include <string>
@@ skipping 217 matching lines @@
                 // Run tests with no options, a single option, or all the
                 // options enabled to avoid a combinatorial explosion.
                 if (enabled_options > 1 &&
                     enabled_options < kMaxEnabledOptions) {
                   continue;
                 }
 
                 for (const QuicVersionVector& client_versions :
                      version_buckets) {
                   CHECK(!client_versions.empty());
+                  if (FilterSupportedVersions(client_versions).empty()) {
+                    continue;
+                  }
                   // Add an entry for server and client supporting all versions.
                   params.push_back(TestParams(
                       client_versions, all_supported_versions,
                       client_versions.front(),
                       client_supports_stateless_rejects,
                       server_uses_stateless_rejects_if_peer_supported,
                       congestion_control_tag, disable_hpack_dynamic_table,
                       force_hol_blocking, use_cheap_stateless_reject,
                       buffer_packet_till_chlo));
 
                   // Run version negotiation tests tests with no options, or all
                   // the options enabled to avoid a combinatorial explosion.
                   if (enabled_options > 0 &&
                       enabled_options < kMaxEnabledOptions) {
                     continue;
                   }
 
                   // Test client supporting all versions and server supporting 1
                   // version. Simulate an old server and exercise version
                   // downgrade in the client. Protocol negotiation should occur.
                   // Skip the i = 0 case because it is essentially the same as
                   // the default case.
                   for (size_t i = 1; i < client_versions.size(); ++i) {
                     QuicVersionVector server_supported_versions;
                     server_supported_versions.push_back(client_versions[i]);
+                    if (FilterSupportedVersions(server_supported_versions)
+                            .empty()) {
+                      continue;
+                    }
                     params.push_back(TestParams(
                         client_versions, server_supported_versions,
                         server_supported_versions.front(),
                         client_supports_stateless_rejects,
                         server_uses_stateless_rejects_if_peer_supported,
                         congestion_control_tag, disable_hpack_dynamic_table,
                         force_hol_blocking, use_cheap_stateless_reject,
                         buffer_packet_till_chlo));
                   }  // End of version for loop.
                 }    // End of 2nd version for loop.
@@ skipping 914 matching lines @@
   ReliableQuicStreamPeer::SetStreamBytesWritten(3, stream);
 
   client_->SendData("bar", true);
   client_->WaitForWriteToFlush();
 
   // By default the stream protects itself from writes after terminte is set.
   // Override this to test the server handling buggy clients.
   ReliableQuicStreamPeer::SetWriteSideClosed(false,
                                              client_->GetOrCreateStream());
 
-  EXPECT_DFATAL(client_->SendData("eep", true), "Fin already buffered");
+  EXPECT_QUIC_BUG(client_->SendData("eep", true), "Fin already buffered");
 }
 
 TEST_P(EndToEndTest, Timeout) {
   client_config_.SetIdleConnectionStateLifetime(
       QuicTime::Delta::FromMicroseconds(500),
       QuicTime::Delta::FromMicroseconds(500));
   // Note: we do NOT ASSERT_TRUE: we may time out during initial handshake:
   // that's enough to validate timeout in this case.
   Initialize();
   while (client_->client()->connected()) {
@@ skipping 1668 matching lines @@
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net