public static IReturnsResult <CloudBlobStream> ReturnsCompletingAsynchronously(
this ISetup <CloudBlobStream, IAsyncResult> setup, AsyncCompletionSource completionSource)
{
if (setup == null)
{
throw new ArgumentNullException("setup");
}
return(setup.Returns <byte[], int, int, AsyncCallback, object>((i1, i2, i3, callback, state) =>
{
CompletingAsyncResult result = new CompletingAsyncResult(callback, state);
completionSource.SetAsyncResult(result);
return result;
}));
}
public static IReturnsResult<Stream> ReturnsCompletingAsynchronously(this ISetup<Stream, IAsyncResult> setup,
AsyncCompletionSource completionSource)
{
if (setup == null)
{
throw new ArgumentNullException("setup");
}
return setup.Returns<byte[], int, int, AsyncCallback, object>((i1, i2, i3, callback, state) =>
{
CompletingAsyncResult result = new CompletingAsyncResult(callback, state);
completionSource.SetAsyncResult(result);
return result;
});
}
public void EndWrite_WhenInnerStreamThrows_PropogatesException()
{
// Arrange
Exception expectedException = new Exception();
Mock<Stream> innerStreamMock = CreateMockInnerStream();
AsyncCompletionSource completion = new AsyncCompletionSource();
innerStreamMock
.SetupBeginWrite()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.SetupEndWrite()
.Throws(expectedException);
Stream innerStream = innerStreamMock.Object;
Stream product = CreateProductUnderTest(innerStream);
byte[] buffer = new byte[0];
int offset = 123;
int count = 456;
AsyncCallback callback = null;
object state = null;
IAsyncResult result = product.BeginWrite(buffer, offset, count, callback, state);
completion.Complete();
// Act & Assert
Exception exception = Assert.Throws<Exception>(() => product.EndWrite(result));
Assert.Same(expectedException, exception);
}
public void EndWrite_DuringCallback_DelegatesToInnerStreamEndWrite()
{
// Arrange
Mock<Stream> innerStreamMock = CreateMockInnerStream();
AsyncCompletionSource completion = new AsyncCompletionSource();
innerStreamMock
.SetupBeginWrite()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.Setup(s => s.EndWrite(It.Is<IAsyncResult>((ar) => ar == completion.AsyncResult)))
.Verifiable();
Stream innerStream = innerStreamMock.Object;
Stream product = CreateProductUnderTest(innerStream);
byte[] buffer = new byte[0];
int offset = 123;
int count = 456;
bool callbackCalled = false;
AsyncCallback callback = (ar) =>
{
product.EndWrite(ar);
callbackCalled = true;
};
object state = null;
IAsyncResult result = product.BeginWrite(buffer, offset, count, callback, state);
// Act
completion.Complete();
// Assert
Assert.True(callbackCalled);
innerStreamMock.Verify();
}
public void BeginWrite_WhenCompletedAsynchronously_CallsCallbackAndCompletesResult()
{
// Arrange
object expectedState = new object();
ExpectedAsyncResult expectedResult = new ExpectedAsyncResult
{
AsyncState = expectedState,
CompletedSynchronously = false,
IsCompleted = true
};
bool callbackCalled = false;
IAsyncResult callbackResult = null;
Stream product = null;
AsyncCallback callback = (ar) =>
{
callbackResult = ar;
AssertEqual(expectedResult, ar);
callbackCalled = true;
};
Mock<Stream> innerStreamMock = CreateMockInnerStream();
AsyncCompletionSource completion = new AsyncCompletionSource();
innerStreamMock
.SetupBeginWrite()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock.SetupEndWrite();
Stream innerStream = innerStreamMock.Object;
product = CreateProductUnderTest(innerStream);
byte[] buffer = new byte[0];
int offset = 123;
int count = 456;
IAsyncResult result = product.BeginWrite(buffer, offset, count, callback, expectedState);
// Act
completion.Complete();
// Assert
Assert.True(callbackCalled);
// An AsyncCallback must be called with the same IAsyncResult instance as the Begin method returned.
Assert.Same(result, callbackResult);
AssertEqual(expectedResult, result, disposeActual: true);
}
public void EndRead_DelegatesToInnerStreamEndRead()
{
// Arrange
int expectedBytesRead = 789;
Mock<Stream> innerStreamMock = CreateMockInnerStream();
AsyncCompletionSource completion = new AsyncCompletionSource();
innerStreamMock
.SetupBeginRead()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.Setup(s => s.EndRead(It.Is<IAsyncResult>(ar => ar == completion.AsyncResult)))
.Returns(expectedBytesRead)
.Verifiable();
Stream innerStream = innerStreamMock.Object;
Stream product = CreateProductUnderTest(innerStream);
byte[] buffer = new byte[0];
int offset = 123;
int count = 456;
AsyncCallback callback = null;
object state = null;
IAsyncResult result = product.BeginRead(buffer, offset, count, callback, state);
completion.Complete();
// Act
int bytesRead = product.EndRead(result);
// Assert
Assert.Equal(expectedBytesRead, bytesRead);
innerStreamMock.Verify();
}