Add new TEST_P parameters to quic_headers_stream_test.

net/quic/quic_headers_stream_test.cc

 // Copyright 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 "net/quic/quic_headers_stream.h"
 
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_bug_tracker.h"
@@ skipping 19 matching lines @@
 using testing::_;
 using testing::AtLeast;
 using testing::HasSubstr;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 using testing::WithArgs;
 using testing::_;
 
+// TODO(bnc): Merge these correctly.
+bool FLAGS_use_http2_frame_decoder_adapter;
+bool FLAGS_use_nested_spdy_framer_decoder;
+bool FLAGS_spdy_use_hpack_decoder2;
+bool FLAGS_spdy_framer_use_new_methods2;
+
 namespace net {
 namespace test {
 
 class MockHpackDebugVisitor : public QuicHeadersStream::HpackDebugVisitor {
  public:
   explicit MockHpackDebugVisitor() : HpackDebugVisitor() {}
 
   MOCK_METHOD1(OnUseEntry, void(QuicTime::Delta elapsed));
 
  private:
@@ skipping 81 matching lines @@
   size_t total_acked_bytes() { return total_acked_bytes_; }
 
  private:
   ~ForceHolAckListener() override {}
 
   size_t total_acked_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(ForceHolAckListener);
 };
 
-// Run all tests with each version, perspective (client or server),
-// and relevant flag options (false or true)
+enum Http2DecoderChoice {
+  HTTP2_DECODER_SPDY,
+  HTTP2_DECODER_NESTED_SPDY,
+  HTTP2_DECODER_NEW
+};
+ostream& operator<<(ostream& os, Http2DecoderChoice v) {
+  switch (v) {
+    case HTTP2_DECODER_SPDY:
+      return os << "SPDY";
+    case HTTP2_DECODER_NESTED_SPDY:
+      return os << "NESTED_SPDY";
+    case HTTP2_DECODER_NEW:
+      return os << "NEW";
+  }
+}
+
+enum HpackDecoderChoice { HPACK_DECODER_SPDY, HPACK_DECODER_NEW };
+ostream& operator<<(ostream& os, HpackDecoderChoice v) {
+  switch (v) {
+    case HPACK_DECODER_SPDY:
+      return os << "SPDY";
+    case HPACK_DECODER_NEW:
+      return os << "NEW";
+  }
+}
+
+typedef std::
+    tuple<QuicVersion, Perspective, Http2DecoderChoice, HpackDecoderChoice>
+        TestParamsTuple;
+
 struct TestParams {
-  TestParams(QuicVersion version, Perspective perspective)
-      : version(version), perspective(perspective) {}
-
-  friend ostream& operator<<(ostream& os, const TestParams& p) {
-    os << "{ version: " << QuicVersionToString(p.version);
-    os << ", perspective: " << p.perspective << " }";
-    return os;
+  explicit TestParams(TestParamsTuple params)
+      : version(std::get<0>(params)),
+        perspective(std::get<1>(params)),
+        http2_decoder(std::get<2>(params)),
+        hpack_decoder(std::get<3>(params)) {
+    switch (http2_decoder) {
+      case HTTP2_DECODER_SPDY:
+        FLAGS_use_nested_spdy_framer_decoder = false;
+        FLAGS_use_http2_frame_decoder_adapter = false;
+        break;
+      case HTTP2_DECODER_NESTED_SPDY:
+        FLAGS_use_nested_spdy_framer_decoder = true;
+        FLAGS_use_http2_frame_decoder_adapter = false;
+        break;
+      case HTTP2_DECODER_NEW:
+        FLAGS_use_nested_spdy_framer_decoder = false;
+        FLAGS_use_http2_frame_decoder_adapter = true;
+        // Http2FrameDecoderAdapter needs the new header methods, else
+        // --use_http2_frame_decoder_adapter=true will be ignored.
+        FLAGS_spdy_framer_use_new_methods2 = true;
+        break;
+    }
+    switch (hpack_decoder) {
+      case HPACK_DECODER_SPDY:
+        FLAGS_spdy_use_hpack_decoder2 = false;
+        break;
+      case HPACK_DECODER_NEW:
+        FLAGS_spdy_use_hpack_decoder2 = true;
+        // Needs new header methods to be used.
+        FLAGS_spdy_framer_use_new_methods2 = true;
+        break;
+    }
+    FLAGS_quic_supports_push_promise = true;
+    FLAGS_quic_always_log_bugs_for_tests = true;
+    VLOG(1) << "TestParams: version: " << QuicVersionToString(version)
+              << ", perspective: " << perspective
+              << ", http2_decoder: " << http2_decoder
+              << ", hpack_decoder: " << hpack_decoder;
   }
 
   QuicVersion version;
   Perspective perspective;
+  Http2DecoderChoice http2_decoder;
+  HpackDecoderChoice hpack_decoder;
 };
 
-// Constructs various test permutations.
-vector<TestParams> GetTestParams() {
-  vector<TestParams> params;
-  QuicVersionVector all_supported_versions = QuicSupportedVersions();
-  for (const QuicVersion version : all_supported_versions) {
-    params.push_back(TestParams(version, Perspective::IS_CLIENT));
-    params.push_back(TestParams(version, Perspective::IS_SERVER));
-  }
-  FLAGS_quic_supports_push_promise = true;
-  return params;
-}
-
-class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
+class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParamsTuple> {
  public:
+  // Constructing the test_params_ object will set the necessary flags before
+  // the MockQuicConnection is constructed, which we need because the latter
+  // will construct a SpdyFramer that will use those flags to decide whether
+  // to construct a decoder adapter.
   QuicHeadersStreamTest()
-      : connection_(new StrictMock<MockQuicConnection>(&helper_,
+      : test_params_(GetParam()),
+        connection_(new StrictMock<MockQuicConnection>(&helper_,
                                                        &alarm_factory_,
                                                        perspective(),
                                                        GetVersion())),
         session_(connection_),
         headers_stream_(QuicSpdySessionPeer::GetHeadersStream(&session_)),
         body_("hello world"),
         hpack_encoder_visitor_(new StrictMock<MockHpackDebugVisitor>),
         hpack_decoder_visitor_(new StrictMock<MockHpackDebugVisitor>),
         stream_frame_(kHeadersStreamId, /*fin=*/false, /*offset=*/0, ""),
         next_promised_stream_id_(2) {
-    FLAGS_quic_always_log_bugs_for_tests = true;
     headers_[":version"] = "HTTP/1.1";
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
     framer_ = std::unique_ptr<SpdyFramer>(new SpdyFramer(HTTP2));
     framer_->set_visitor(&visitor_);
     EXPECT_EQ(version(), session_.connection()->version());
     EXPECT_TRUE(headers_stream_ != nullptr);
-    VLOG(1) << GetParam();
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   }
 
   QuicConsumedData SaveIov(const QuicIOVector& data) {
     const iovec* iov = data.iov;
     int count = data.iov_count;
     int consumed = 0;
     for (int i = 0; i < count; ++i) {
       saved_data_.append(static_cast<char*>(iov[i].iov_base), iov[i].iov_len);
       consumed += iov[i].iov_len;
@@ skipping 96 matching lines @@
 
     CheckHeaders();
     saved_data_.clear();
   }
 
   void CheckHeaders() {
     EXPECT_EQ(headers_, headers_handler_->decoded_block());
     headers_handler_.reset();
   }
 
-  Perspective perspective() { return GetParam().perspective; }
+  Perspective perspective() const { return test_params_.perspective; }
 
-  QuicVersion version() { return GetParam().version; }
+  QuicVersion version() const { return test_params_.version; }
 
   QuicVersionVector GetVersion() {
     QuicVersionVector versions;
     versions.push_back(version());
     return versions;
   }
 
   void TearDownLocalConnectionState() {
     QuicConnectionPeer::TearDownLocalConnectionState(connection_);
   }
 
   QuicStreamId NextPromisedStreamId() { return next_promised_stream_id_ += 2; }
 
   static const bool kFrameComplete = true;
   static const bool kHasPriority = true;
 
+  const TestParams test_params_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   StrictMock<MockQuicConnection>* connection_;
   StrictMock<MockQuicSpdySession> session_;
   QuicHeadersStream* headers_stream_;
   SpdyHeaderBlock headers_;
   std::unique_ptr<TestHeadersHandler> headers_handler_;
   string body_;
   string saved_data_;
   string saved_header_data_;
   string saved_payloads_;
   std::unique_ptr<SpdyFramer> framer_;
   StrictMock<MockVisitor> visitor_;
   std::unique_ptr<StrictMock<MockHpackDebugVisitor>> hpack_encoder_visitor_;
   std::unique_ptr<StrictMock<MockHpackDebugVisitor>> hpack_decoder_visitor_;
   QuicStreamFrame stream_frame_;
   QuicStreamId next_promised_stream_id_;
 };
 
-INSTANTIATE_TEST_CASE_P(Tests,
-                        QuicHeadersStreamTest,
-                        ::testing::ValuesIn(GetTestParams()));
+// Run all tests with each version, perspective (client or server),
+// HTTP/2 and HPACK decoder.
+INSTANTIATE_TEST_CASE_P(
+    Tests,
+    QuicHeadersStreamTest,
+    ::testing::Combine(
+        ::testing::ValuesIn(QuicSupportedVersions()),
+        ::testing::Values(Perspective::IS_CLIENT, Perspective::IS_SERVER),
+        ::testing::Values(HTTP2_DECODER_SPDY,
+                          HTTP2_DECODER_NESTED_SPDY,
+                          HTTP2_DECODER_NEW),
+        ::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER_NEW)));
 
 TEST_P(QuicHeadersStreamTest, StreamId) {
   EXPECT_EQ(3u, headers_stream_->id());
 }
 
 TEST_P(QuicHeadersStreamTest, WriteHeaders) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : kFins) {
       if (perspective() == Perspective::IS_SERVER) {
@@ skipping 540 matching lines @@
       }
       saved_data_.clear();
       saved_payloads_.clear();
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net