public void Read_ReadsEffectiveLengthBytes(
            int from,
            int to,
            int innerLength,
            int effectiveLength
            )
        {
            // Arrange
            var mockInnerStream = new Mock <Stream>();

            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            var range  = new RangeItemHeaderValue(from, to);
            var data   = new byte[25];
            var offset = 5;

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                rangeStream.Read(data, offset, data.Length);

                // Assert
                mockInnerStream.Verify(s => s.Read(data, offset, effectiveLength), Times.Once());
                Assert.Equal(effectiveLength, rangeStream.Position);
            }
        }
        public async Task Read_CanReadAfterLength()
        {
            // Arrange
            var originalText = "This is the whole text.";
            var range        = new RangeItemHeaderValue(0L, null);
            var data         = new byte[25];

            using (var innerStream = new MemoryStream())
                using (var writer = new StreamWriter(innerStream))
                {
                    await writer.WriteAsync(originalText);

                    await writer.FlushAsync();

                    using (var rangeStream = new ByteRangeStream(innerStream, range))
                    {
                        rangeStream.Position = 50L;

                        // Act
                        var read = rangeStream.Read(data, 0, data.Length);

                        // Assert
                        Assert.Equal(0, read);
                    }
                }
        }
Exemple #3
0
        public void Read_ReadsEffectiveLengthBytes(int from, int to, int innerLength, int effectiveLength)
        {
            // Arrange
            Mock <Stream> mockInnerStream = new Mock <Stream>();

            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            RangeItemHeaderValue range = new RangeItemHeaderValue(from, to);

            byte[] data   = new byte[25];
            int    offset = 5;

            // Act
            ByteRangeStream rangeStream = new ByteRangeStream(mockInnerStream.Object, range);

            rangeStream.Read(data, offset, data.Length);

            // Assert
            mockInnerStream.Verify(s => s.Read(data, offset, effectiveLength), Times.Once());
        }
        public void Read_ReadsEffectiveLengthBytes(int from, int to, int innerLength, int effectiveLength)
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            RangeItemHeaderValue range = new RangeItemHeaderValue(from, to);
            byte[] data = new byte[25];
            int offset = 5;

            // Act
            ByteRangeStream rangeStream = new ByteRangeStream(mockInnerStream.Object, range);
            rangeStream.Read(data, offset, data.Length);

            // Assert
            mockInnerStream.Verify(s => s.Read(data, offset, effectiveLength), Times.Once());
        }