public void IfCanSeekIsFalseLengthAndPositionShouldNotBeCalled() { var baseStream = new DelegateStream( canReadFunc: () => true, canSeekFunc: () => false, readFunc: (buffer, offset, count) => 0); var trackingStream = new CallTrackingStream(baseStream); var dest = Stream.Null; trackingStream.CopyTo(dest); Assert.InRange(trackingStream.TimesCalled(nameof(trackingStream.CanSeek)), 0, 1); Assert.Equal(0, trackingStream.TimesCalled(nameof(trackingStream.Length))); Assert.Equal(0, trackingStream.TimesCalled(nameof(trackingStream.Position))); // We can't override CopyTo since it's not virtual, so checking TimesCalled // for CopyTo will result in 0. Instead, we check that Read was called, // and validate the parameters passed there. Assert.Equal(1, trackingStream.TimesCalled(nameof(trackingStream.Read))); byte[] outerBuffer = trackingStream.ReadBuffer; int outerOffset = trackingStream.ReadOffset; int outerCount = trackingStream.ReadCount; Assert.NotNull(outerBuffer); Assert.InRange(outerOffset, 0, outerBuffer.Length - outerCount); Assert.InRange(outerCount, 1, int.MaxValue); // the buffer can't be size 0 }
public async Task ShouldNotFlushUnderlyingStreamIfReadOnly(bool underlyingCanSeek) { var underlying = new DelegateStream( canReadFunc: () => true, canWriteFunc: () => false, canSeekFunc: () => underlyingCanSeek, readFunc: (_, __, ___) => 123, writeFunc: (_, __, ___) => { throw new NotSupportedException(); }, seekFunc: (_, __) => 123L ); var wrapper = new CallTrackingStream(underlying); var buffered = new BufferedStream(wrapper); buffered.ReadByte(); buffered.Flush(); Assert.Equal(0, wrapper.TimesCalled(nameof(wrapper.Flush))); await buffered.FlushAsync(); Assert.Equal(0, wrapper.TimesCalled(nameof(wrapper.FlushAsync))); }
public async Task ShouldAlwaysFlushUnderlyingStreamIfWritable(bool underlyingCanRead, bool underlyingCanSeek) { var underlying = new DelegateStream( canReadFunc: () => underlyingCanRead, canWriteFunc: () => true, canSeekFunc: () => underlyingCanSeek, readFunc: (_, __, ___) => 123, writeFunc: (_, __, ___) => { }, seekFunc: (_, __) => 123L ); var wrapper = new CallTrackingStream(underlying); var buffered = new BufferedStream(wrapper); buffered.Flush(); Assert.Equal(1, wrapper.TimesCalled(nameof(wrapper.Flush))); await buffered.FlushAsync(); Assert.Equal(1, wrapper.TimesCalled(nameof(wrapper.FlushAsync))); buffered.WriteByte(0); buffered.Flush(); Assert.Equal(2, wrapper.TimesCalled(nameof(wrapper.Flush))); await buffered.FlushAsync(); Assert.Equal(2, wrapper.TimesCalled(nameof(wrapper.FlushAsync))); }
public async void AsyncIfCanSeekIsTrueLengthAndPositionShouldOnlyBeCalledOnce() { var baseStream = new DelegateStream( canReadFunc: () => true, canSeekFunc: () => true, readFunc: (buffer, offset, count) => 0, lengthFunc: () => 0L, positionGetFunc: () => 0L); var trackingStream = new CallTrackingStream(baseStream); var dest = Stream.Null; await trackingStream.CopyToAsync(dest); Assert.InRange(trackingStream.TimesCalled(nameof(trackingStream.Length)), 0, 1); Assert.InRange(trackingStream.TimesCalled(nameof(trackingStream.Position)), 0, 1); }
public void IfLengthMinusPositionPositiveOverflowsBufferSizeShouldStillBePositive(long length, long position) { // The new implementation of Stream.CopyTo calculates the bytes left // in the Stream by calling Length - Position. This can overflow to a // negative number, so this tests that if that happens we don't send // in a negative bufferSize. var baseStream = new DelegateStream( canReadFunc: () => true, canSeekFunc: () => true, lengthFunc: () => length, positionGetFunc: () => position, readFunc: (buffer, offset, count) => 0); var trackingStream = new CallTrackingStream(baseStream); var dest = Stream.Null; trackingStream.CopyTo(dest); // CopyTo is not virtual, so we can't override it in // CallTrackingStream and record the arguments directly. // Instead, validate the arguments passed to Read. Assert.Equal(1, trackingStream.TimesCalled(nameof(trackingStream.Read))); byte[] outerBuffer = trackingStream.ReadBuffer; int outerOffset = trackingStream.ReadOffset; int outerCount = trackingStream.ReadCount; Assert.NotNull(outerBuffer); Assert.InRange(outerOffset, 0, outerBuffer.Length - outerCount); Assert.InRange(outerCount, 1, int.MaxValue); }
public void IfLengthIsLessThanOrEqualToPositionCopyToShouldStillBeCalledWithAPositiveBufferSize(long length, long position) { // Streams with their Lengths <= their Positions, e.g. // new MemoryStream { Position = 3 }.SetLength(1) // should still be called CopyTo{Async} on with a // bufferSize of at least 1. var baseStream = new DelegateStream( canReadFunc: () => true, canSeekFunc: () => true, lengthFunc: () => length, positionGetFunc: () => position, readFunc: (buffer, offset, count) => 0); var trackingStream = new CallTrackingStream(baseStream); var dest = Stream.Null; trackingStream.CopyTo(dest); // CopyTo is not virtual, so we can't override it in // CallTrackingStream and record the arguments directly. // Instead, validate the arguments passed to Read. Assert.Equal(1, trackingStream.TimesCalled(nameof(trackingStream.Read))); byte[] outerBuffer = trackingStream.ReadBuffer; int outerOffset = trackingStream.ReadOffset; int outerCount = trackingStream.ReadCount; Assert.NotNull(outerBuffer); Assert.InRange(outerOffset, 0, outerBuffer.Length - outerCount); Assert.InRange(outerCount, 1, int.MaxValue); }
public async void AsyncIfCanSeekIsFalseLengthAndPositionShouldNotBeCalled() { var baseStream = new DelegateStream( canReadFunc: () => true, canSeekFunc: () => false, readFunc: (buffer, offset, count) => 0); var trackingStream = new CallTrackingStream(baseStream); var dest = Stream.Null; await trackingStream.CopyToAsync(dest); Assert.InRange(trackingStream.TimesCalled(nameof(trackingStream.CanSeek)), 0, 1); Assert.Equal(0, trackingStream.TimesCalled(nameof(trackingStream.Length))); Assert.Equal(0, trackingStream.TimesCalled(nameof(trackingStream.Position))); Assert.Equal(1, trackingStream.TimesCalled(nameof(trackingStream.CopyToAsync))); Assert.Same(dest, trackingStream.CopyToAsyncDestination); Assert.InRange(trackingStream.CopyToAsyncBufferSize, 1, int.MaxValue); Assert.Equal(CancellationToken.None, trackingStream.CopyToAsyncCancellationToken); }
public void SetPositionInsideBufferRange_Read_WillNotReadUnderlyingStreamAgain(int sharedBufSize, Action <Stream, long> setPos) { var trackingStream = new CallTrackingStream(new MemoryStream()); var bufferedStream = new BufferedStream(trackingStream, sharedBufSize); bufferedStream.Write(Enumerable.Range(0, sharedBufSize * 2).Select(i => (byte)i).ToArray(), 0, sharedBufSize * 2); setPos(bufferedStream, 0); var readBuf = new byte[sharedBufSize - 1]; // First half part verification byte[] expectedReadBuf = Enumerable.Range(0, sharedBufSize - 1).Select(i => (byte)i).ToArray(); // Call Read() to fill shared read buffer int readBytes = bufferedStream.Read(readBuf, 0, readBuf.Length); Assert.Equal(readBuf.Length, readBytes); Assert.Equal(sharedBufSize - 1, bufferedStream.Position); Assert.Equal(expectedReadBuf, readBuf); Assert.Equal(1, trackingStream.TimesCalled(nameof(trackingStream.Read))); // Set position inside range of shared read buffer for (int pos = 0; pos < sharedBufSize - 1; pos++) { setPos(bufferedStream, pos); readBytes = bufferedStream.Read(readBuf, pos, readBuf.Length - pos); Assert.Equal(readBuf.Length - pos, readBytes); Assert.Equal(sharedBufSize - 1, bufferedStream.Position); Assert.Equal(expectedReadBuf, readBuf); // Should not trigger underlying stream's Read() Assert.Equal(1, trackingStream.TimesCalled(nameof(trackingStream.Read))); } Assert.Equal(sharedBufSize - 1, bufferedStream.ReadByte()); Assert.Equal(sharedBufSize, bufferedStream.Position); // Should not trigger underlying stream's Read() Assert.Equal(1, trackingStream.TimesCalled(nameof(trackingStream.Read))); // Second half part verification expectedReadBuf = Enumerable.Range(sharedBufSize, sharedBufSize - 1).Select(i => (byte)i).ToArray(); // Call Read() to fill shared read buffer readBytes = bufferedStream.Read(readBuf, 0, readBuf.Length); Assert.Equal(readBuf.Length, readBytes); Assert.Equal(sharedBufSize * 2 - 1, bufferedStream.Position); Assert.Equal(expectedReadBuf, readBuf); Assert.Equal(2, trackingStream.TimesCalled(nameof(trackingStream.Read))); // Set position inside range of shared read buffer for (int pos = 0; pos < sharedBufSize - 1; pos++) { setPos(bufferedStream, sharedBufSize + pos); readBytes = bufferedStream.Read(readBuf, pos, readBuf.Length - pos); Assert.Equal(readBuf.Length - pos, readBytes); Assert.Equal(sharedBufSize * 2 - 1, bufferedStream.Position); Assert.Equal(expectedReadBuf, readBuf); // Should not trigger underlying stream's Read() Assert.Equal(2, trackingStream.TimesCalled(nameof(trackingStream.Read))); } Assert.Equal(sharedBufSize * 2 - 1, bufferedStream.ReadByte()); Assert.Equal(sharedBufSize * 2, bufferedStream.Position); // Should not trigger underlying stream's Read() Assert.Equal(2, trackingStream.TimesCalled(nameof(trackingStream.Read))); }
public async void AsyncIfLengthIsGreaterThanPositionAndDoesNotOverflowEverythingShouldGoNormally(long length, long position) { const int ReadLimit = 7; // Lambda state byte[] outerBuffer = null; int? outerOffset = null; int? outerCount = null; int readsLeft = ReadLimit; var srcBase = new DelegateStream( canReadFunc: () => true, canSeekFunc: () => true, lengthFunc: () => length, positionGetFunc: () => position, readFunc: (buffer, offset, count) => { Assert.NotNull(buffer); Assert.InRange(offset, 0, buffer.Length - count); Assert.InRange(count, 1, int.MaxValue); // CopyTo should always pass in the same buffer/offset/count if (outerBuffer != null) { Assert.Same(outerBuffer, buffer); } else { outerBuffer = buffer; } if (outerOffset != null) { Assert.Equal(outerOffset, offset); } else { outerOffset = offset; } if (outerCount != null) { Assert.Equal(outerCount, count); } else { outerCount = count; } return(--readsLeft); // CopyTo will call Read on this ReadLimit times before stopping }); var src = new CallTrackingStream(srcBase); var destBase = new DelegateStream( canWriteFunc: () => true, writeFunc: (buffer, offset, count) => { Assert.Same(outerBuffer, buffer); Assert.Equal(outerOffset, offset); Assert.Equal(readsLeft, count); }); var dest = new CallTrackingStream(destBase); await src.CopyToAsync(dest); // Since we override CopyToAsync in CallTrackingStream, // src.Read will actually not get called ReadLimit // times, src.Inner.Read will. So, we just assert that // CopyToAsync was called once for src. Assert.Equal(1, src.TimesCalled(nameof(src.CopyToAsync))); Assert.Equal(ReadLimit - 1, dest.TimesCalled(nameof(dest.WriteAsync))); // dest.WriteAsync will still get called repeatedly }
public void IfLengthIsGreaterThanPositionAndDoesNotOverflowEverythingShouldGoNormally(long length, long position) { const int ReadLimit = 7; // Lambda state byte[] outerBuffer = null; int? outerOffset = null; int? outerCount = null; int readsLeft = ReadLimit; var srcBase = new DelegateStream( canReadFunc: () => true, canSeekFunc: () => true, lengthFunc: () => length, positionGetFunc: () => position, readFunc: (buffer, offset, count) => { Assert.NotNull(buffer); Assert.InRange(offset, 0, buffer.Length - count); Assert.InRange(count, 1, int.MaxValue); // CopyTo should always pass in the same buffer/offset/count if (outerBuffer != null) { Assert.Same(outerBuffer, buffer); } else { outerBuffer = buffer; } if (outerOffset != null) { Assert.Equal(outerOffset, offset); } else { outerOffset = offset; } if (outerCount != null) { Assert.Equal(outerCount, count); } else { outerCount = count; } return(--readsLeft); // CopyTo will call Read on this ReadLimit times before stopping }); var src = new CallTrackingStream(srcBase); var destBase = new DelegateStream( canWriteFunc: () => true, writeFunc: (buffer, offset, count) => { Assert.Same(outerBuffer, buffer); Assert.Equal(outerOffset, offset); Assert.Equal(readsLeft, count); }); var dest = new CallTrackingStream(destBase); src.CopyTo(dest); Assert.Equal(ReadLimit, src.TimesCalled(nameof(src.Read))); Assert.Equal(ReadLimit - 1, dest.TimesCalled(nameof(dest.Write))); }