Re-write some quic_stream_test and enable TLS blocked tests. gfe-relnote: test only, not protected. PiperOrigin-RevId: 268926212 Change-Id: I4e86c141bdb36dd96a8177a4b8d6603416e08366
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc index 3b0becc..97863ad 100644 --- a/quic/core/quic_stream_test.cc +++ b/quic/core/quic_stream_test.cc
@@ -8,6 +8,8 @@ #include <string> #include "net/third_party/quiche/src/quic/core/quic_connection.h" +#include "net/third_party/quiche/src/quic/core/quic_constants.h" +#include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/core/quic_versions.h" #include "net/third_party/quiche/src/quic/core/quic_write_blocked_list.h" @@ -72,8 +74,7 @@ class QuicStreamTestBase : public QuicTestWithParam<ParsedQuicVersion> { public: QuicStreamTestBase() - : initial_flow_control_window_bytes_(kMaxOutgoingPacketSize), - zero_(QuicTime::Delta::Zero()), + : zero_(QuicTime::Delta::Zero()), supported_versions_(AllSupportedVersions()) {} void Initialize() { @@ -83,11 +84,13 @@ &helper_, &alarm_factory_, Perspective::IS_SERVER, version_vector); connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1)); session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_); + session_->Initialize(); - // New streams rely on having the peer's flow control receive window - // negotiated in the config. - QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow( - session_->config(), initial_flow_control_window_bytes_); + QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow( + session_->config(), kMinimumFlowControlSendWindow); + QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams( + session_->config(), 10); + session_->OnConfigNegotiated(); stream_ = new TestStream(kTestStreamId, session_.get(), BIDIRECTIONAL); EXPECT_NE(nullptr, stream_); @@ -103,10 +106,6 @@ bool fin_sent() { return stream_->fin_sent(); } bool rst_sent() { return stream_->rst_sent(); } - void set_initial_flow_control_window_bytes(uint32_t val) { - initial_flow_control_window_bytes_ = val; - } - bool HasWriteBlockedStreams() { return write_blocked_list_->HasWriteBlockedSpecialStream() || write_blocked_list_->HasWriteBlockedDataStreams(); @@ -140,7 +139,6 @@ std::unique_ptr<MockQuicSession> session_; TestStream* stream_; QuicWriteBlockedList* write_blocked_list_; - uint32_t initial_flow_control_window_bytes_; QuicTime::Delta zero_; ParsedQuicVersionVector supported_versions_; QuicStreamId kTestStreamId = @@ -506,8 +504,6 @@ } TEST_P(QuicStreamTest, StreamFlowControlMultipleWindowUpdates) { - set_initial_flow_control_window_bytes(1000); - Initialize(); // If we receive multiple WINDOW_UPDATES (potentially out of order), then we @@ -515,12 +511,12 @@ // Initially should be default. EXPECT_EQ( - initial_flow_control_window_bytes_, + kMinimumFlowControlSendWindow, QuicFlowControllerPeer::SendWindowOffset(stream_->flow_controller())); // Check a single WINDOW_UPDATE results in correct offset. QuicWindowUpdateFrame window_update_1(kInvalidControlFrameId, stream_->id(), - 1234); + kMinimumFlowControlSendWindow + 5); stream_->OnWindowUpdateFrame(window_update_1); EXPECT_EQ( window_update_1.byte_offset, @@ -531,7 +527,7 @@ QuicWindowUpdateFrame window_update_2(kInvalidControlFrameId, stream_->id(), 1); QuicWindowUpdateFrame window_update_3(kInvalidControlFrameId, stream_->id(), - 9999); + kMinimumFlowControlSendWindow + 10); QuicWindowUpdateFrame window_update_4(kInvalidControlFrameId, stream_->id(), 5678); stream_->OnWindowUpdateFrame(window_update_2); @@ -723,11 +719,6 @@ } TEST_P(QuicParameterizedStreamTest, SetDrainingIncomingOutgoing) { - if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) { - // TODO(nharper, b/112643533): Figure out why this test fails when TLS is - // enabled and fix it. - return; - } // Don't have incoming data consumed. Initialize(); @@ -757,11 +748,6 @@ } TEST_P(QuicParameterizedStreamTest, SetDrainingOutgoingIncoming) { - if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) { - // TODO(nharper, b/112643533): Figure out why this test fails when TLS is - // enabled and fix it. - return; - } // Don't have incoming data consumed. Initialize(); @@ -1023,8 +1009,6 @@ TEST_P(QuicStreamTest, WriteBufferedData) { // Set buffered data low water mark to be 100. SetQuicFlag(FLAGS_quic_buffered_data_threshold, 100); - // Do not stream level flow control block this stream. - set_initial_flow_control_window_bytes(500000); Initialize(); std::string data(1024, 'a'); @@ -1159,8 +1143,6 @@ TEST_P(QuicStreamTest, WriteMemSlices) { // Set buffered data low water mark to be 100. SetQuicFlag(FLAGS_quic_buffered_data_threshold, 100); - // Do not flow control block this stream. - set_initial_flow_control_window_bytes(500000); Initialize(); char data[1024]; @@ -1403,47 +1385,60 @@ } TEST_P(QuicStreamTest, MarkConnectionLevelWriteBlockedOnWindowUpdateFrame) { - // Set a small initial control window size. - set_initial_flow_control_window_bytes(100); Initialize(); + // Set the config to a small value so that a newly created stream has small + // send flow control window. + QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(session_->config(), + 100); + auto stream = new TestStream(GetNthClientInitiatedBidirectionalStreamId( + GetParam().transport_version, 2), + session_.get(), BIDIRECTIONAL); + session_->ActivateStream(QuicWrapUnique(stream)); + EXPECT_CALL(*session_, WritevData(_, _, _, _, _)) .WillRepeatedly(Invoke(MockQuicSession::ConsumeData)); EXPECT_CALL(*connection_, SendControlFrame(_)) .WillOnce(Invoke(&ClearControlFrame)); std::string data(1024, '.'); - stream_->WriteOrBufferData(data, false, nullptr); + stream->WriteOrBufferData(data, false, nullptr); EXPECT_FALSE(HasWriteBlockedStreams()); QuicWindowUpdateFrame window_update(kInvalidControlFrameId, stream_->id(), 1234); - stream_->OnWindowUpdateFrame(window_update); + stream->OnWindowUpdateFrame(window_update); // Verify stream is marked connection level write blocked. EXPECT_TRUE(HasWriteBlockedStreams()); - EXPECT_TRUE(stream_->HasBufferedData()); + EXPECT_TRUE(stream->HasBufferedData()); } // Regression test for b/73282665. TEST_P(QuicStreamTest, MarkConnectionLevelWriteBlockedOnWindowUpdateFrameWithNoBufferedData) { - // Set a small initial flow control window size. - const uint32_t kSmallWindow = 100; - set_initial_flow_control_window_bytes(kSmallWindow); Initialize(); - std::string data(kSmallWindow, '.'); + // Set the config to a small value so that a newly created stream has small + // send flow control window. + QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(session_->config(), + 100); + auto stream = new TestStream(GetNthClientInitiatedBidirectionalStreamId( + GetParam().transport_version, 2), + session_.get(), BIDIRECTIONAL); + session_->ActivateStream(QuicWrapUnique(stream)); + + std::string data(100, '.'); EXPECT_CALL(*session_, WritevData(_, _, _, _, _)) .WillRepeatedly(Invoke(MockQuicSession::ConsumeData)); EXPECT_CALL(*connection_, SendControlFrame(_)) .WillOnce(Invoke(&ClearControlFrame)); - stream_->WriteOrBufferData(data, false, nullptr); + stream->WriteOrBufferData(data, false, nullptr); EXPECT_FALSE(HasWriteBlockedStreams()); QuicWindowUpdateFrame window_update(kInvalidControlFrameId, stream_->id(), 120); - stream_->OnWindowUpdateFrame(window_update); - EXPECT_FALSE(stream_->HasBufferedData()); + stream->OnWindowUpdateFrame(window_update); + EXPECT_FALSE(stream->HasBufferedData()); // Verify stream is marked as blocked although there is no buffered data. EXPECT_TRUE(HasWriteBlockedStreams()); }