public void Flush_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
subject.Flush();
mockStream.Verify(s => s.Flush(), Times.Once);
}
public void SetLength_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var length = 1L;
subject.SetLength(length);
mockStream.Verify(s => s.SetLength(length), Times.Once);
}
public void EndWrite_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var mockAsyncResult = new Mock <IAsyncResult>();
subject.EndWrite(mockAsyncResult.Object);
mockStream.Verify(s => s.EndWrite(mockAsyncResult.Object), Times.Once);
}
public void WriteByte_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
byte b = 1;
subject.WriteByte(b);
mockStream.Verify(s => s.WriteByte(b), Times.Once);
}
public void Equals_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
mockStream.Setup(s => s.Equals(subject)).Returns(true);
var result = subject.Equals(subject);
result.Should().BeTrue();
mockStream.Verify(s => s.Equals(subject), Times.Once);
}
public void Write_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var buffer = new byte[3];
var offset = 1;
var count = 2;
subject.Write(buffer, offset, count);
mockStream.Verify(s => s.Write(buffer, offset, count), Times.Once);
}
public void InnerStreamIsOpenOnDispose()
{
// Arrange
var innerStream = new MemoryStream();
var delegatingStream = new DelegatingStream(innerStream);
// Act
delegatingStream.Dispose();
// Assert
Assert.True(innerStream.CanRead);
}
public void InnerStreamIsOpenOnDispose()
{
// Arrange
var innerStream = new MemoryStream();
var delegatingStream = new DelegatingStream(innerStream);
// Act
delegatingStream.Dispose();
// Assert
Assert.True(innerStream.CanRead);
}
public void GetHashCode_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var hashCode = 123;
mockStream.Setup(s => s.GetHashCode()).Returns(hashCode);
var result = subject.GetHashCode();
result.Should().Be(hashCode);
mockStream.Verify(s => s.GetHashCode(), Times.Once);
}
public void ReadByte_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var b = 1;
mockStream.Setup(s => s.ReadByte()).Returns(b);
var result = subject.ReadByte();
result.Should().Be(b);
mockStream.Verify(s => s.ReadByte(), Times.Once);
}
public void ToString_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var toString = "123";
mockStream.Setup(s => s.ToString()).Returns(toString);
var result = subject.ToString();
result.Should().Be(toString);
mockStream.Verify(s => s.ToString(), Times.Once);
}
public void CanSeek_should_call_wrapped_stream(
[Values(false, true)]
bool canSeek)
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
mockStream.SetupGet(s => s.CanSeek).Returns(canSeek);
var result = subject.CanSeek;
result.Should().Be(canSeek);
mockStream.VerifyGet(s => s.CanSeek, Times.Once);
}
public void EndRead_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var mockAsyncResult = new Mock <IAsyncResult>();
var numberOfBytesRead = 1;
mockStream.Setup(s => s.EndRead(mockAsyncResult.Object)).Returns(numberOfBytesRead);
var result = subject.EndRead(mockAsyncResult.Object);
result.Should().Be(numberOfBytesRead);
mockStream.Verify(s => s.EndRead(mockAsyncResult.Object), Times.Once);
}
public void FlushAsync_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var task = Task.FromResult <object>(null);
var cancellationToken = new CancellationTokenSource().Token;
mockStream.Setup(s => s.FlushAsync(cancellationToken)).Returns(task);
var result = subject.FlushAsync(cancellationToken);
result.Should().Be(task);
mockStream.Verify(s => s.FlushAsync(cancellationToken), Times.Once);
}
public void Seek_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var offset = 1L;
var origin = SeekOrigin.Current;
var newPosition = 2L;
mockStream.Setup(s => s.Seek(offset, origin)).Returns(newPosition);
var result = subject.Seek(offset, origin);
result.Should().Be(newPosition);
mockStream.Verify(s => s.Seek(offset, origin), Times.Once);
}
public void CopyToAsync_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var mockDestination = new Mock <Stream>();
var bufferSize = 1;
var cancellationToken = new CancellationTokenSource().Token;
var task1 = Task.FromResult <object>(null);
mockStream.Setup(s => s.CopyToAsync(mockDestination.Object, bufferSize, cancellationToken)).Returns(task1);
var result = subject.CopyToAsync(mockDestination.Object, bufferSize, cancellationToken);
result.Should().Be(task1);
mockStream.Verify(s => s.CopyToAsync(mockDestination.Object, bufferSize, cancellationToken), Times.Once);
}
public void Read_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var buffer = new byte[3];
var offset = 1;
var count = 2;
var numberOfBytesRead = 1;
mockStream.Setup(s => s.Read(buffer, offset, count)).Returns(numberOfBytesRead);
var result = subject.Read(buffer, offset, count);
result.Should().Be(numberOfBytesRead);
mockStream.Verify(s => s.Read(buffer, offset, count), Times.Once);
}
public void WriteAsync_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var buffer = new byte[3];
var offset = 1;
var count = 2;
var cancellationToken = new CancellationTokenSource().Token;
var task = Task.FromResult <object>(null);
mockStream.Setup(s => s.WriteAsync(buffer, offset, count, cancellationToken)).Returns(task);
var result = subject.WriteAsync(buffer, offset, count, cancellationToken);
result.Should().Be(task);
mockStream.Verify(s => s.WriteAsync(buffer, offset, count, cancellationToken), Times.Once);
}
public override async Task WriteResponseBodyAsync(OutputFormatterContext context)
{
var contact = (Contact)context.Object;
var builder = new StringBuilder();
builder.AppendLine("BEGIN:VCARD");
builder.AppendFormat("FN:{0}", contact.Name);
builder.AppendLine();
builder.AppendLine("END:VCARD");
var responseStream = new DelegatingStream(context.ActionContext.HttpContext.Response.Body);
using (var writer = new StreamWriter(responseStream, context.SelectedEncoding, bufferSize: 1024))
{
await writer.WriteAsync(builder.ToString());
}
}
public void BeginWrite_should_call_wrapped_stream()
{
var mockStream = new Mock <Stream>();
var subject = new DelegatingStream(mockStream.Object);
var buffer = new byte[0];
var offset = 1;
var count = 2;
var mockCallback = new Mock <AsyncCallback>();
var state = new object();
var mockAsyncResult = new Mock <IAsyncResult>();
mockStream.Setup(s => s.BeginWrite(buffer, offset, count, mockCallback.Object, state)).Returns(mockAsyncResult.Object);
var result = subject.BeginWrite(buffer, offset, count, mockCallback.Object, state);
result.Should().BeSameAs(mockAsyncResult.Object);
mockStream.Verify(s => s.BeginWrite(buffer, offset, count, mockCallback.Object, state), Times.Once);
}
