| public Seek ( long offset, SeekOrigin, origin ) : long | ||
| offset | long | |
| origin | SeekOrigin, | |
| return | long | |
/// <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);
}
}
