/// <summary> /// Wraps a generic stream into a block stream using the specified transformer and blocksize. /// </summary> /// <remarks>The wrapped stream must be writable and seekable</remarks> /// <param name="wrappedStream">Stream to wrap</param> /// <param name="transformer">The block transformer to use</param> /// <param name="blockSize">Block size to use</param> public BlockWriteOnceStream(Stream wrappedStream, IBlockTransformer transformer, short blockSize = BLOCK_SIZE) : base(wrappedStream, transformer, blockSize) { currentBlock = new byte[BlockSize]; WrappedStream.Seek(0, SeekOrigin.Begin); wrappedStream.SetLength(0); }
public async Task Parameterized_Methods_Are_Properly_Wrapped() { var strm = Substitute.For <Stream>(); strm.CanRead.Returns(true); strm.CanWrite.Returns(true); using (var wrprstrm = new WrappedStream(strm, false)) { wrprstrm.Seek(0, SeekOrigin.Current); strm.Received(1).Seek(0, SeekOrigin.Current); wrprstrm.SetLength(10); strm.Received(1).SetLength(10); var arrByte = new byte[5]; wrprstrm.Read(arrByte, 0, arrByte.Length); strm.Received(1).Read(arrByte, 0, arrByte.Length); wrprstrm.Write(arrByte, 0, arrByte.Length); strm.Received(1).Write(arrByte, 0, arrByte.Length); var anotherStrm = new MemoryStream(); await wrprstrm.CopyToAsync(anotherStrm, 1, CancellationToken.None).ConfigureAwait(false); await strm.Received(1).CopyToAsync(anotherStrm, 1, CancellationToken.None).ConfigureAwait(false); await wrprstrm.FlushAsync(CancellationToken.None).ConfigureAwait(false); await strm.Received(1).FlushAsync(CancellationToken.None).ConfigureAwait(false); await wrprstrm.WriteAsync(arrByte, 1, arrByte.Length, CancellationToken.None).ConfigureAwait(false); await strm.Received(1) .WriteAsync(arrByte, 1, arrByte.Length, CancellationToken.None) .ConfigureAwait(false); await wrprstrm.ReadAsync(arrByte, 1, arrByte.Length, CancellationToken.None).ConfigureAwait(false); await strm.Received(1) .ReadAsync(arrByte, 1, arrByte.Length, CancellationToken.None) .ConfigureAwait(false); wrprstrm.WriteByte(20); strm.Received(1).WriteByte(20); var _ = wrprstrm.Equals(null); var __ = strm.Received(1).Equals(null); } }
public override long Seek(long offset, SeekOrigin origin) { switch (origin) { case SeekOrigin.Begin: offset += m_Offset; if (offset > m_Offset + m_Size) { offset = m_Offset + m_Size; } if (offset < m_Offset) { offset = m_Offset; } break; case SeekOrigin.End: offset -= (m_Offset + m_Size); if (offset > 0) { offset = 0; } if (offset < -m_Size) { offset = -m_Size; } break; default: if (m_Position + offset > m_Offset + m_Size) { offset = (m_Offset + m_Size) - m_Position; } if (m_Position + offset < m_Offset) { offset = m_Offset - m_Position; } break; } m_Position = WrappedStream.Seek(offset, origin); return(m_Position - m_Offset); }
public override long Seek(long offset, SeekOrigin origin) { return(WrappedStream.Seek(offset, origin)); }
/// <summary> /// Sets the position within the current stream. /// </summary> /// <param name="offset">A byte offset relative to the <paramref name="origin"/> parameter.</param> /// <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"/> indicating the reference point used to obtain the new position.</param> /// <returns>The new position within the current stream.</returns> public override long Seek(long offset, SeekOrigin origin) { ThrowIfDisposed(); return(WrappedStream.Seek(offset, origin)); }
public async Task Parameterized_Methods_Are_Properly_Wrapped() { var strm = Substitute.For <Stream>(); using (var wrprstrm = new WrappedStream(strm, false)) { wrprstrm.Seek(0, SeekOrigin.Current); strm.Received(1).Seek(0, SeekOrigin.Current); wrprstrm.SetLength(10); strm.Received(1).SetLength(10); var arrByte = new byte[5]; wrprstrm.Read(arrByte, 0, arrByte.Length); strm.Received(1).Read(arrByte, 0, arrByte.Length); wrprstrm.Write(arrByte, 0, arrByte.Length); strm.Received(1).Write(arrByte, 0, arrByte.Length); var anotherStrm = new MemoryStream(); await wrprstrm.CopyToAsync(anotherStrm, 1, CancellationToken.None).ConfigureAwait(false); await strm.Received(1).CopyToAsync(anotherStrm, 1, CancellationToken.None).ConfigureAwait(false); await wrprstrm.FlushAsync(CancellationToken.None).ConfigureAwait(false); await strm.Received(1).FlushAsync(CancellationToken.None).ConfigureAwait(false); await wrprstrm.WriteAsync(arrByte, 1, arrByte.Length, CancellationToken.None).ConfigureAwait(false); await strm.Received(1) .WriteAsync(arrByte, 1, arrByte.Length, CancellationToken.None) .ConfigureAwait(false); await wrprstrm.ReadAsync(arrByte, 1, arrByte.Length, CancellationToken.None).ConfigureAwait(false); await strm.Received(1) .ReadAsync(arrByte, 1, arrByte.Length, CancellationToken.None) .ConfigureAwait(false); var cb = new AsyncCallback(ar => { }); var result = wrprstrm.BeginRead(arrByte, 0, arrByte.Length, cb, null); strm.Received(1).BeginRead(arrByte, 0, arrByte.Length, cb, null); wrprstrm.BeginWrite(arrByte, 0, arrByte.Length, cb, null); strm.Received(1).BeginWrite(arrByte, 0, arrByte.Length, cb, null); #if FEATURE_REMOTING wrprstrm.CreateObjRef(null); strm.Received(1).CreateObjRef(null); wrprstrm.InitializeLifetimeService(); strm.Received(1).InitializeLifetimeService(); #else Assert.True(Assert.Throws <RemotingException>(() => wrprstrm.CreateObjRef(null)) .Message.Equals(WrappedStream.RemotingErrorTxt)); Assert.True(Assert.Throws <RemotingException>(() => wrprstrm.InitializeLifetimeService()) .Message.Equals(WrappedStream.RemotingErrorTxt)); #endif wrprstrm.EndRead(result); strm.Received(1).EndRead(result); wrprstrm.EndWrite(result); strm.Received(1).EndWrite(result); wrprstrm.WriteByte(20); strm.Received(1).WriteByte(20); wrprstrm.Equals(null); strm.Received(1).Equals(null); } }