blob: 9b459ed2319cb0eb620451a41a264e727df7c4ce [file] [log] [blame]
// Copyright (c) 2018 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/third_party/quic/core/legacy_quic_stream_id_manager.h"
#include "net/third_party/quic/core/quic_utils.h"
#include "net/third_party/quic/platform/api/quic_ptr_util.h"
#include "net/third_party/quic/platform/api/quic_test.h"
#include "net/third_party/quic/test_tools/quic_session_peer.h"
#include "net/third_party/quic/test_tools/quic_test_utils.h"
namespace quic {
namespace test {
namespace {
using testing::_;
using testing::StrictMock;
class LegacyQuicStreamIdManagerTest : public QuicTest {
protected:
void Initialize(Perspective perspective) {
SetQuicReloadableFlag(quic_enable_version_99, false);
connection_ = new MockQuicConnection(
&helper_, &alarm_factory_, perspective,
ParsedVersionOfIndex(CurrentSupportedVersions(), 0));
session_ = QuicMakeUnique<StrictMock<MockQuicSession>>(connection_);
manager_ = QuicSessionPeer::GetStreamIdManager(session_.get());
session_->Initialize();
}
QuicStreamId GetNthClientInitiatedId(int n) { return 3 + 2 * n; }
QuicStreamId GetNthServerInitiatedId(int n) { return 2 + 2 * n; }
MockQuicConnectionHelper helper_;
MockAlarmFactory alarm_factory_;
MockQuicConnection* connection_;
std::unique_ptr<StrictMock<MockQuicSession>> session_;
LegacyQuicStreamIdManager* manager_;
};
class LegacyQuicStreamIdManagerTestServer
: public LegacyQuicStreamIdManagerTest {
protected:
LegacyQuicStreamIdManagerTestServer() { Initialize(Perspective::IS_SERVER); }
};
TEST_F(LegacyQuicStreamIdManagerTestServer, CanOpenNextOutgoingStream) {
EXPECT_TRUE(manager_->CanOpenNextOutgoingStream(
manager_->max_open_outgoing_streams() - 1));
EXPECT_FALSE(manager_->CanOpenNextOutgoingStream(
manager_->max_open_outgoing_streams()));
}
TEST_F(LegacyQuicStreamIdManagerTestServer, CanOpenIncomingStream) {
EXPECT_TRUE(manager_->CanOpenIncomingStream(
manager_->max_open_incoming_streams() - 1));
EXPECT_FALSE(
manager_->CanOpenIncomingStream(manager_->max_open_incoming_streams()));
}
TEST_F(LegacyQuicStreamIdManagerTestServer, AvailableStreams) {
ASSERT_TRUE(
manager_->MaybeIncreaseLargestPeerStreamId(GetNthClientInitiatedId(3)));
EXPECT_TRUE(manager_->IsAvailableStream(GetNthClientInitiatedId(1)));
EXPECT_TRUE(manager_->IsAvailableStream(GetNthClientInitiatedId(2)));
ASSERT_TRUE(
manager_->MaybeIncreaseLargestPeerStreamId(GetNthClientInitiatedId(2)));
ASSERT_TRUE(
manager_->MaybeIncreaseLargestPeerStreamId(GetNthClientInitiatedId(1)));
}
TEST_F(LegacyQuicStreamIdManagerTestServer, MaxAvailableStreams) {
// Test that the server closes the connection if a client makes too many data
// streams available. The server accepts slightly more than the negotiated
// stream limit to deal with rare cases where a client FIN/RST is lost.
const size_t kMaxStreamsForTest = 10;
session_->OnConfigNegotiated();
const size_t kAvailableStreamLimit = manager_->MaxAvailableStreams();
EXPECT_EQ(
manager_->max_open_incoming_streams() * kMaxAvailableStreamsMultiplier,
manager_->MaxAvailableStreams());
// The protocol specification requires that there can be at least 10 times
// as many available streams as the connection's maximum open streams.
EXPECT_LE(10 * kMaxStreamsForTest, kAvailableStreamLimit);
EXPECT_TRUE(
manager_->MaybeIncreaseLargestPeerStreamId(GetNthClientInitiatedId(0)));
// Establish available streams up to the server's limit.
const int kLimitingStreamId =
GetNthClientInitiatedId(kAvailableStreamLimit + 1);
// This exceeds the stream limit. In versions other than 99
// this is allowed. Version 99 hews to the IETF spec and does
// not allow it.
EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(kLimitingStreamId));
// A further available stream will result in connection close.
EXPECT_CALL(*connection_,
CloseConnection(QUIC_TOO_MANY_AVAILABLE_STREAMS, _, _));
// This forces stream kLimitingStreamId + 2 to become available, which
// violates the quota.
EXPECT_FALSE(
manager_->MaybeIncreaseLargestPeerStreamId(kLimitingStreamId + 2 * 2));
}
TEST_F(LegacyQuicStreamIdManagerTestServer, MaximumAvailableOpenedStreams) {
QuicStreamId stream_id = GetNthClientInitiatedId(0);
EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
stream_id + 2 * (manager_->max_open_incoming_streams() - 1)));
}
TEST_F(LegacyQuicStreamIdManagerTestServer, TooManyAvailableStreams) {
QuicStreamId stream_id = GetNthClientInitiatedId(0);
EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
// A stream ID which is too large to create.
QuicStreamId stream_id2 =
GetNthClientInitiatedId(2 * manager_->MaxAvailableStreams() + 4);
EXPECT_CALL(*connection_,
CloseConnection(QUIC_TOO_MANY_AVAILABLE_STREAMS, _, _));
EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(stream_id2));
}
TEST_F(LegacyQuicStreamIdManagerTestServer, ManyAvailableStreams) {
// When max_open_streams_ is 200, should be able to create 200 streams
// out-of-order, that is, creating the one with the largest stream ID first.
manager_->set_max_open_incoming_streams(200);
QuicStreamId stream_id = GetNthClientInitiatedId(0);
EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
// Create the largest stream ID of a threatened total of 200 streams.
// GetNth... starts at 0, so for 200 streams, get the 199th.
EXPECT_TRUE(
manager_->MaybeIncreaseLargestPeerStreamId(GetNthClientInitiatedId(199)));
}
TEST_F(LegacyQuicStreamIdManagerTestServer,
TestMaxIncomingAndOutgoingStreamsAllowed) {
// Tests that on server side, the value of max_open_incoming/outgoing
// streams are setup correctly during negotiation. The value for outgoing
// stream is limited to negotiated value and for incoming stream it is set to
// be larger than that.
session_->OnConfigNegotiated();
// The max number of open outgoing streams is less than that of incoming
// streams, and it should be same as negotiated value.
EXPECT_LT(manager_->max_open_outgoing_streams(),
manager_->max_open_incoming_streams());
EXPECT_EQ(manager_->max_open_outgoing_streams(),
kDefaultMaxStreamsPerConnection);
EXPECT_GT(manager_->max_open_incoming_streams(),
kDefaultMaxStreamsPerConnection);
}
class LegacyQuicStreamIdManagerTestClient
: public LegacyQuicStreamIdManagerTest {
protected:
LegacyQuicStreamIdManagerTestClient() { Initialize(Perspective::IS_CLIENT); }
};
TEST_F(LegacyQuicStreamIdManagerTestClient,
TestMaxIncomingAndOutgoingStreamsAllowed) {
// Tests that on client side, the value of max_open_incoming/outgoing
// streams are setup correctly during negotiation. When flag is true, the
// value for outgoing stream is limited to negotiated value and for incoming
// stream it is set to be larger than that.
session_->OnConfigNegotiated();
EXPECT_LT(manager_->max_open_outgoing_streams(),
manager_->max_open_incoming_streams());
EXPECT_EQ(manager_->max_open_outgoing_streams(),
kDefaultMaxStreamsPerConnection);
}
} // namespace
} // namespace test
} // namespace quic