public async ValueTask DisposeAsyncThrows()
{
var classUnderTest = new DisposalTracker();
await classUnderTest.DisposeAsync();
var ex = await Record.ExceptionAsync(() => classUnderTest.DisposeAsync());
Assert.NotNull(ex);
Assert.IsType <ObjectDisposedException>(ex);
}
public ValueTask DisposeAsync()
{
if (disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
disposed = true;
return(disposalTracker.DisposeAsync());
}
public async ValueTask NoExceptions_DoesNotThrow()
{
var classUnderTest = new DisposalTracker();
var obj = Substitute.For <IDisposable, InterfaceProxy <IDisposable> >();
classUnderTest.Add(obj);
var ex = await Record.ExceptionAsync(() => classUnderTest.DisposeAsync());
Assert.Null(ex);
obj.Received().Dispose();
}
/// <inheritdoc/>
public async ValueTask DisposeAsync()
{
if (disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
disposed = true;
await disposalTracker.DisposeAsync();
executor?.Dispose();
}
public async ValueTask MultipleExceptions_ThrowsAggregateException()
{
var classUnderTest = new DisposalTracker();
var obj1 = Substitute.For <IDisposable, InterfaceProxy <IDisposable> >();
obj1.When(x => x.Dispose()).Throw <DivideByZeroException>();
classUnderTest.Add(obj1);
var obj2 = Substitute.For <IDisposable, InterfaceProxy <IDisposable> >();
obj2.When(x => x.Dispose()).Throw <InvalidOperationException>();
classUnderTest.Add(obj2);
var ex = await Record.ExceptionAsync(() => classUnderTest.DisposeAsync());
var aggEx = Assert.IsType <AggregateException>(ex);
Assert.Collection(
aggEx.InnerExceptions,
ex => Assert.IsType <InvalidOperationException>(ex),
ex => Assert.IsType <DivideByZeroException>(ex)
);
}
public async ValueTask SingleException_CleansUpAllObjects_ThrowsTheSingleException()
{
var classUnderTest = new DisposalTracker();
var obj1 = Substitute.For <IDisposable, InterfaceProxy <IDisposable> >();
classUnderTest.Add(obj1);
var thrown = new DivideByZeroException();
var obj2 = Substitute.For <IDisposable, InterfaceProxy <IDisposable> >();
obj2.When(x => x.Dispose()).Throw(thrown);
classUnderTest.Add(obj2);
var obj3 = Substitute.For <IDisposable, InterfaceProxy <IDisposable> >();
classUnderTest.Add(obj3);
var ex = await Record.ExceptionAsync(() => classUnderTest.DisposeAsync());
Assert.Same(thrown, ex);
obj1.Received().Dispose();
obj2.Received().Dispose();
obj3.Received().Dispose();
}
/// <inheritdoc/>
public void Dispose()
{
// Have to do disposal on a background thread, since we can't guarantee that disposal
// will be synchronous (and we can't change the contract of ISourceInformationProvider).
Task.Run(async() => await disposalTracker.DisposeAsync());
}
