// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Buffers;
using System.Collections.Generic;
using System.IO.Pipelines;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Connections;
using Microsoft.AspNetCore.Connections.Features;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.Kestrel.Core.Adapter.Internal;
using Microsoft.AspNetCore.Server.Kestrel.Core.Internal;
using Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Infrastructure;
using Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions.Internal;
using Microsoft.AspNetCore.Testing;
using Moq;
using Xunit;

namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
{
    public class HttpConnectionTests : IDisposable
    {
        private readonly MemoryPool<byte> _memoryPool;
        private readonly HttpConnectionContext _httpConnectionContext;
        private readonly HttpConnection _httpConnection;

        public HttpConnectionTests()
        {
            _memoryPool = KestrelMemoryPool.Create();
            var options = new PipeOptions(_memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
            var pair = DuplexPipe.CreateConnectionPair(options, options);

            var connectionFeatures = new FeatureCollection();
            connectionFeatures.Set(Mock.Of<IConnectionLifetimeFeature>());
            connectionFeatures.Set(Mock.Of<IBytesWrittenFeature>());

            _httpConnectionContext = new HttpConnectionContext
            {
                ConnectionId = "0123456789",
                ConnectionContext = Mock.Of<ConnectionContext>(),
                ConnectionAdapters = new List<IConnectionAdapter>(),
                ConnectionFeatures = connectionFeatures,
                MemoryPool = _memoryPool,
                Transport = pair.Transport,
                ServiceContext = new TestServiceContext
                {
                    SystemClock = new SystemClock()
                }
            };

            _httpConnection = new HttpConnection(_httpConnectionContext);
        }

        public void Dispose()
        {
            _memoryPool.Dispose();
        }

        [Fact]
        public void DoesNotTimeOutWhenDebuggerIsAttached()
        {
            var mockDebugger = new Mock<IDebugger>();
            mockDebugger.SetupGet(g => g.IsAttached).Returns(true);
            _httpConnection.Debugger = mockDebugger.Object;
            _httpConnection.Initialize(_httpConnectionContext.Transport);

            var now = DateTimeOffset.Now;
            _httpConnection.Tick(now);
            _httpConnection.SetTimeout(1, TimeoutAction.SendTimeoutResponse);
            _httpConnection.Tick(now.AddTicks(2).Add(Heartbeat.Interval));

            Assert.False(_httpConnection.RequestTimedOut);
        }

        [Fact]
        public void DoesNotTimeOutWhenRequestBodyDoesNotSatisfyMinimumDataRateButDebuggerIsAttached()
        {
            var mockDebugger = new Mock<IDebugger>();
            mockDebugger.SetupGet(g => g.IsAttached).Returns(true);
            _httpConnection.Debugger = mockDebugger.Object;
            var bytesPerSecond = 100;
            var mockLogger = new Mock<IKestrelTrace>();
            mockLogger.Setup(l => l.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>())).Throws(new InvalidOperationException("Should not log"));

            TickBodyWithMinimumDataRate(mockLogger.Object, bytesPerSecond);

            Assert.False(_httpConnection.RequestTimedOut);
        }

        [Fact]
        public void TimesOutWhenRequestBodyDoesNotSatisfyMinimumDataRate()
        {
            var bytesPerSecond = 100;
            var mockLogger = new Mock<IKestrelTrace>();
            TickBodyWithMinimumDataRate(mockLogger.Object, bytesPerSecond);

            // Timed out
            Assert.True(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Once);
        }

        private void TickBodyWithMinimumDataRate(IKestrelTrace logger, int bytesPerSecond)
        {
            var gracePeriod = TimeSpan.FromSeconds(5);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinRequestBodyDataRate =
                new MinDataRate(bytesPerSecond: bytesPerSecond, gracePeriod: gracePeriod);

            _httpConnectionContext.ServiceContext.Log = logger;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();

            // Initialize timestamp
            var now = DateTimeOffset.UtcNow;
            _httpConnection.Tick(now);

            _httpConnection.StartTimingReads();

            // Tick after grace period w/ low data rate
            now += gracePeriod + TimeSpan.FromSeconds(1);
            _httpConnection.BytesRead(1);
            _httpConnection.Tick(now);
        }

        [Fact]
        public void RequestBodyMinimumDataRateNotEnforcedDuringGracePeriod()
        {
            var bytesPerSecond = 100;
            var gracePeriod = TimeSpan.FromSeconds(2);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinRequestBodyDataRate =
                new MinDataRate(bytesPerSecond: bytesPerSecond, gracePeriod: gracePeriod);

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();

            // Initialize timestamp
            var now = DateTimeOffset.UtcNow;
            _httpConnection.Tick(now);

            _httpConnection.StartTimingReads();

            // Tick during grace period w/ low data rate
            now += TimeSpan.FromSeconds(1);
            _httpConnection.BytesRead(10);
            _httpConnection.Tick(now);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Never);

            // Tick after grace period w/ low data rate
            now += TimeSpan.FromSeconds(2);
            _httpConnection.BytesRead(10);
            _httpConnection.Tick(now);

            // Timed out
            Assert.True(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Once);
        }

        [Fact]
        public void RequestBodyDataRateIsAveragedOverTimeSpentReadingRequestBody()
        {
            var bytesPerSecond = 100;
            var gracePeriod = TimeSpan.FromSeconds(2);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinRequestBodyDataRate =
                new MinDataRate(bytesPerSecond: bytesPerSecond, gracePeriod: gracePeriod);

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();

            // Initialize timestamp
            var now = DateTimeOffset.UtcNow;
            _httpConnection.Tick(now);

            _httpConnection.StartTimingReads();

            // Set base data rate to 200 bytes/second
            now += gracePeriod;
            _httpConnection.BytesRead(400);
            _httpConnection.Tick(now);

            // Data rate: 200 bytes/second
            now += TimeSpan.FromSeconds(1);
            _httpConnection.BytesRead(200);
            _httpConnection.Tick(now);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Never);

            // Data rate: 150 bytes/second
            now += TimeSpan.FromSeconds(1);
            _httpConnection.BytesRead(0);
            _httpConnection.Tick(now);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Never);

            // Data rate: 120 bytes/second
            now += TimeSpan.FromSeconds(1);
            _httpConnection.BytesRead(0);
            _httpConnection.Tick(now);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Never);

            // Data rate: 100 bytes/second
            now += TimeSpan.FromSeconds(1);
            _httpConnection.BytesRead(0);
            _httpConnection.Tick(now);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Never);

            // Data rate: ~85 bytes/second
            now += TimeSpan.FromSeconds(1);
            _httpConnection.BytesRead(0);
            _httpConnection.Tick(now);

            // Timed out
            Assert.True(_httpConnection.RequestTimedOut);
            mockLogger.Verify(logger =>
                logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), bytesPerSecond), Times.Once);
        }

        [Fact]
        public void RequestBodyDataRateNotComputedOnPausedTime()
        {
            var systemClock = new MockSystemClock();

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinRequestBodyDataRate =
                new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(2));
            _httpConnectionContext.ServiceContext.SystemClock = systemClock;

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();

            // Initialize timestamp
            _httpConnection.Tick(systemClock.UtcNow);

            _httpConnection.StartTimingReads();

            // Tick at 3s, expected counted time is 3s, expected data rate is 200 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(3);
            _httpConnection.BytesRead(600);
            _httpConnection.Tick(systemClock.UtcNow);

            // Pause at 3.5s
            systemClock.UtcNow += TimeSpan.FromSeconds(0.5);
            _httpConnection.PauseTimingReads();

            // Tick at 4s, expected counted time is 4s (first tick after pause goes through), expected data rate is 150 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(0.5);
            _httpConnection.Tick(systemClock.UtcNow);

            // Tick at 6s, expected counted time is 4s, expected data rate is 150 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(2);
            _httpConnection.Tick(systemClock.UtcNow);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(
                logger => logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()),
                Times.Never);

            // Resume at 6.5s
            systemClock.UtcNow += TimeSpan.FromSeconds(0.5);
            _httpConnection.ResumeTimingReads();

            // Tick at 9s, expected counted time is 6s, expected data rate is 100 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(1.5);
            _httpConnection.Tick(systemClock.UtcNow);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(
                logger => logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()),
                Times.Never);

            // Tick at 10s, expected counted time is 7s, expected data rate drops below 100 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(1);
            _httpConnection.Tick(systemClock.UtcNow);

            // Timed out
            Assert.True(_httpConnection.RequestTimedOut);
            mockLogger.Verify(
                logger => logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()),
                Times.Once);
        }

        [Fact]
        public void ReadTimingNotPausedWhenResumeCalledBeforeNextTick()
        {
            var systemClock = new MockSystemClock();

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinRequestBodyDataRate =
                new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(2));
            _httpConnectionContext.ServiceContext.SystemClock = systemClock;

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();

            // Initialize timestamp
            _httpConnection.Tick(systemClock.UtcNow);

            _httpConnection.StartTimingReads();

            // Tick at 2s, expected counted time is 2s, expected data rate is 100 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(2);
            _httpConnection.BytesRead(200);
            _httpConnection.Tick(systemClock.UtcNow);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(
                logger => logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()),
                Times.Never);

            // Pause at 2.25s
            systemClock.UtcNow += TimeSpan.FromSeconds(0.25);
            _httpConnection.PauseTimingReads();

            // Resume at 2.5s
            systemClock.UtcNow += TimeSpan.FromSeconds(0.25);
            _httpConnection.ResumeTimingReads();

            // Tick at 3s, expected counted time is 3s, expected data rate is 100 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(0.5);
            _httpConnection.BytesRead(100);
            _httpConnection.Tick(systemClock.UtcNow);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);
            mockLogger.Verify(
                logger => logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()),
                Times.Never);

            // Tick at 4s, expected counted time is 4s, expected data rate drops below 100 bytes/second
            systemClock.UtcNow += TimeSpan.FromSeconds(1);
            _httpConnection.Tick(systemClock.UtcNow);

            // Timed out
            Assert.True(_httpConnection.RequestTimedOut);
            mockLogger.Verify(
                logger => logger.RequestBodyMininumDataRateNotSatisfied(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()),
                Times.Once);
        }

        [Fact]
        public void ReadTimingNotEnforcedWhenTimeoutIsSet()
        {
            var systemClock = new MockSystemClock();
            var timeout = TimeSpan.FromSeconds(5);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinRequestBodyDataRate =
                new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(2));
            _httpConnectionContext.ServiceContext.SystemClock = systemClock;

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();

            var startTime = systemClock.UtcNow;

            // Initialize timestamp
            _httpConnection.Tick(startTime);

            _httpConnection.StartTimingReads();

            _httpConnection.SetTimeout(timeout.Ticks, TimeoutAction.StopProcessingNextRequest);

            // Tick beyond grace period with low data rate
            systemClock.UtcNow += TimeSpan.FromSeconds(3);
            _httpConnection.BytesRead(1);
            _httpConnection.Tick(systemClock.UtcNow);

            // Not timed out
            Assert.False(_httpConnection.RequestTimedOut);

            // Tick just past timeout period, adjusted by Heartbeat.Interval
            systemClock.UtcNow = startTime + timeout + Heartbeat.Interval + TimeSpan.FromTicks(1);
            _httpConnection.Tick(systemClock.UtcNow);

            // Timed out
            Assert.True(_httpConnection.RequestTimedOut);
        }

        [Fact]
        public async Task WriteTimingAbortsConnectionWhenWriteDoesNotCompleteWithMinimumDataRate()
        {
            var systemClock = new MockSystemClock();
            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate =
                new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(2));
            _httpConnectionContext.ServiceContext.SystemClock = systemClock;

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();
            _httpConnection.Http1Connection.RequestAborted.Register(() =>
            {
                aborted.SetResult(null);
            });

            // Initialize timestamp
            _httpConnection.Tick(systemClock.UtcNow);

            // Should complete within 4 seconds, but the timeout is adjusted by adding Heartbeat.Interval
            _httpConnection.StartTimingWrite(400);

            // Tick just past 4s plus Heartbeat.Interval
            systemClock.UtcNow += TimeSpan.FromSeconds(4) + Heartbeat.Interval + TimeSpan.FromTicks(1);
            _httpConnection.Tick(systemClock.UtcNow);

            Assert.True(_httpConnection.RequestTimedOut);
            await aborted.Task.DefaultTimeout();
        }

        [Fact]
        public async Task WriteTimingAbortsConnectionWhenSmallWriteDoesNotCompleteWithinGracePeriod()
        {
            var systemClock = new MockSystemClock();
            var minResponseDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(5));
            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate = minResponseDataRate;
            _httpConnectionContext.ServiceContext.SystemClock = systemClock;

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();
            _httpConnection.Http1Connection.RequestAborted.Register(() =>
            {
                aborted.SetResult(null);
            });

            // Initialize timestamp
            var startTime = systemClock.UtcNow;
            _httpConnection.Tick(startTime);

            // Should complete within 1 second, but the timeout is adjusted by adding Heartbeat.Interval
            _httpConnection.StartTimingWrite(100);

            // Tick just past 1s plus Heartbeat.Interval
            systemClock.UtcNow += TimeSpan.FromSeconds(1) + Heartbeat.Interval + TimeSpan.FromTicks(1);
            _httpConnection.Tick(systemClock.UtcNow);

            // Still within grace period, not timed out
            Assert.False(_httpConnection.RequestTimedOut);

            // Tick just past grace period (adjusted by Heartbeat.Interval)
            systemClock.UtcNow = startTime + minResponseDataRate.GracePeriod + Heartbeat.Interval + TimeSpan.FromTicks(1);
            _httpConnection.Tick(systemClock.UtcNow);

            Assert.True(_httpConnection.RequestTimedOut);
            await aborted.Task.DefaultTimeout();
        }

        [Fact]
        public async Task WriteTimingTimeoutPushedOnConcurrentWrite()
        {
            var systemClock = new MockSystemClock();
            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate =
                new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(2));
            _httpConnectionContext.ServiceContext.SystemClock = systemClock;

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();
            _httpConnection.Http1Connection.RequestAborted.Register(() =>
            {
                aborted.SetResult(null);
            });

            // Initialize timestamp
            _httpConnection.Tick(systemClock.UtcNow);

            // Should complete within 5 seconds, but the timeout is adjusted by adding Heartbeat.Interval
            _httpConnection.StartTimingWrite(500);

            // Start a concurrent write after 3 seconds, which should complete within 3 seconds (adjusted by Heartbeat.Interval)
            _httpConnection.StartTimingWrite(300);

            // Tick just past 5s plus Heartbeat.Interval, when the first write should have completed
            systemClock.UtcNow += TimeSpan.FromSeconds(5) + Heartbeat.Interval + TimeSpan.FromTicks(1);
            _httpConnection.Tick(systemClock.UtcNow);

            // Not timed out because the timeout was pushed by the second write
            Assert.False(_httpConnection.RequestTimedOut);

            // Complete the first write, this should have no effect on the timeout
            _httpConnection.StopTimingWrite();

            // Tick just past +3s, when the second write should have completed
            systemClock.UtcNow += TimeSpan.FromSeconds(3) + TimeSpan.FromTicks(1);
            _httpConnection.Tick(systemClock.UtcNow);

            Assert.True(_httpConnection.RequestTimedOut);
            await aborted.Task.DefaultTimeout();
        }

        [Fact]
        public async Task WriteTimingAbortsConnectionWhenRepeadtedSmallWritesDoNotCompleteWithMinimumDataRate()
        {
            var systemClock = new MockSystemClock();
            var minResponseDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(5));
            var numWrites = 5;
            var writeSize = 100;
            var aborted = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);

            _httpConnectionContext.ServiceContext.ServerOptions.Limits.MinResponseDataRate = minResponseDataRate;
            _httpConnectionContext.ServiceContext.SystemClock = systemClock;

            var mockLogger = new Mock<IKestrelTrace>();
            _httpConnectionContext.ServiceContext.Log = mockLogger.Object;

            _httpConnection.Initialize(_httpConnectionContext.Transport);
            _httpConnection.Http1Connection.Reset();
            _httpConnection.Http1Connection.RequestAborted.Register(() =>
            {
                aborted.SetResult(null);
            });

            // Initialize timestamp
            var startTime = systemClock.UtcNow;
            _httpConnection.Tick(startTime);

            // 5 consecutive 100 byte writes.
            for (var i = 0; i < numWrites - 1; i++)
            {
                _httpConnection.StartTimingWrite(writeSize);
                _httpConnection.StopTimingWrite();
            }

            // Stall the last write.
            _httpConnection.StartTimingWrite(writeSize);

            // Move the clock forward Heartbeat.Interval + MinDataRate.GracePeriod + 4 seconds.
            // The grace period should only be added for the first write. The subsequent 4 100 byte writes should add 1 second each to the timeout given the 100 byte/s min rate.
            systemClock.UtcNow += Heartbeat.Interval + minResponseDataRate.GracePeriod + TimeSpan.FromSeconds((numWrites - 1) * writeSize / minResponseDataRate.BytesPerSecond);
            _httpConnection.Tick(systemClock.UtcNow);

            Assert.False(_httpConnection.RequestTimedOut);

            // On more tick forward triggers the timeout.
            systemClock.UtcNow += TimeSpan.FromTicks(1);
            _httpConnection.Tick(systemClock.UtcNow);

            Assert.True(_httpConnection.RequestTimedOut);
            await aborted.Task.TimeoutAfter(TimeSpan.FromSeconds(10));
        }
    }
}