public override string GetDisposeErrorMessage(SampleDisposable item)
{
// argument checks
Debug.Assert(item != null);
return(item.DisposeErrorMessage);
}
private static void TestStrategy <TException>(DisposeExceptionStrategy strategy, bool throwMain, bool throwDispose, Action <TException> exceptionVerify = null)
where TException : Exception
{
// No return value:
var disposable = new SampleDisposable(throwDispose);
var exception = ExceptionAssert.Throws <TException>(() =>
disposable.Using(strategy, _ => RunMainLogic(throwMain)));
Assert.IsTrue(disposable.WasDisposeCalled);
exceptionVerify?.Invoke(exception);
// With return value:
disposable = new SampleDisposable(throwDispose);
exception = ExceptionAssert.Throws <TException>(() =>
disposable.Using(strategy, _ =>
{
RunMainLogic(throwMain);
return(42);
}));
Assert.IsTrue(disposable.WasDisposeCalled);
exceptionVerify?.Invoke(exception);
}
public override int GetDisposedCount(SampleDisposable item)
{
// argument checks
Debug.Assert(item != null);
return(item.DisposedCount);
}
private static async Task TestStrategyAsync <TException>(DisposeExceptionStrategy strategy, bool throwMain, bool throwDispose, Action <TException> exceptionVerify = null)
where TException : Exception
{
// No return value:
var disposable = new SampleDisposable(throwDispose);
var exception = await ExceptionAssert.ThrowsAsync <TException>(() =>
disposable.UsingAsync(strategy, async _ => await RunMainLogicAsync(throwMain)));
Assert.IsTrue(disposable.WasDisposeCalled);
exceptionVerify?.Invoke(exception);
// With return value:
disposable = new SampleDisposable(throwDispose);
exception = await ExceptionAssert.ThrowsAsync <TException>(() =>
disposable.UsingAsync(strategy, async _ =>
{
await RunMainLogicAsync(throwMain);
return(42);
}));
Assert.IsTrue(disposable.WasDisposeCalled);
exceptionVerify?.Invoke(exception);
}
public void ThrowIfDisposed()
{
var disposable = new SampleDisposable();
disposable.DoSomething();
disposable.Dispose();
var exception = ExceptionAssert.Throws <ObjectDisposedException>(() => disposable.DoSomething());
Assert.AreEqual(nameof(SampleDisposable), exception.ObjectName);
}
public void General_AsExtensionMethod()
{
// ARRANGE
SampleDisposable arg = new SampleDisposable();
// ACT
arg.DisposeSuppressingErrors();
// ASSERT
Assert.Equal(1, arg.DisposedCount);
}
public void General()
{
// ARRANGE
SampleDisposable arg = new SampleDisposable();
// ACT
DisposableUtil.DisposeSuppressingErrors(arg);
// ASSERT
Assert.Equal(1, arg.DisposedCount);
}
public void Args_target_null()
{
// ARRANGE
SampleDisposable arg = null;
// ACT
DisposableUtil.DisposeSuppressingErrors(arg);
// ASSERT
// no ArgumentNullException expected
}
public void Args_target_null()
{
// ARRANGE
SampleDisposable arg = null;
// ACT
DisposableUtil.ClearDisposableObject(ref arg);
// ASSERT
// no ArgumentNullException expected
Assert.Equal(null, arg);
}
public void General()
{
// ARRANGE
SampleDisposable sample = new SampleDisposable();
SampleDisposable arg = sample;
// ACT
DisposableUtil.ClearDisposableObject(ref arg);
// ASSERT
Assert.Equal(null, arg);
Assert.Equal(1, sample.DisposedCount);
}
public void Dispose()
{
var disposable = new SampleDisposable();
Assert.IsFalse(disposable.HasDisposeStarted);
Assert.IsFalse(disposable.HasDisposeCompleted);
Assert.IsFalse(disposable.HasDisposeFailed);
disposable.Dispose();
Assert.IsTrue(disposable.HasDisposeStarted);
Assert.IsTrue(disposable.HasDisposeCompleted);
Assert.IsFalse(disposable.HasDisposeFailed);
Assert.AreEqual(1, disposable.DisposeCount);
disposable.Dispose();
Assert.IsTrue(disposable.HasDisposeStarted);
Assert.IsTrue(disposable.HasDisposeCompleted);
Assert.IsFalse(disposable.HasDisposeFailed);
Assert.AreEqual(1, disposable.DisposeCount);
disposable = new SampleDisposable();
disposable.ThrowException = true;
ExceptionAssert.Throws <InvalidOperationException>(() => disposable.Dispose());
Assert.IsTrue(disposable.HasDisposeStarted);
Assert.IsFalse(disposable.HasDisposeCompleted);
Assert.IsTrue(disposable.HasDisposeFailed);
Assert.AreEqual(1, disposable.DisposeCount);
ExceptionAssert.Throws <InvalidOperationException>(() => disposable.Dispose());
Assert.IsTrue(disposable.HasDisposeStarted);
Assert.IsFalse(disposable.HasDisposeCompleted);
Assert.IsTrue(disposable.HasDisposeFailed);
Assert.AreEqual(2, disposable.DisposeCount);
disposable.ThrowException = false;
disposable.Dispose();
Assert.IsTrue(disposable.HasDisposeStarted);
Assert.IsTrue(disposable.HasDisposeCompleted);
Assert.IsFalse(disposable.HasDisposeFailed);
Assert.AreEqual(3, disposable.DisposeCount);
disposable.Dispose();
Assert.IsTrue(disposable.HasDisposeStarted);
Assert.IsTrue(disposable.HasDisposeCompleted);
Assert.IsFalse(disposable.HasDisposeFailed);
Assert.AreEqual(3, disposable.DisposeCount);
}
public void Error()
{
// ARRANGE
SampleDisposable arg = new SampleDisposable(throwException: true);
TestLogMonitor logMonitor = new TestLogMonitor();
// ACT
logMonitor.StartLogging();
try {
DisposableUtil.DisposeSuppressingErrors(arg);
// no exception expected
} finally {
logMonitor.StopLogging();
}
// ASSERT
Assert.Equal(1, arg.DisposedCount);
LogEntry expectedEntry = new LogEntry(null, TraceEventType.Error, $"Fail to dispose the object at 'DisposeSuppressingErrors.Error()': {arg.DisposeErrorMessage}");
logMonitor.AssertContains(expectedEntry);
}
public void Error()
{
// ARRANGE
SampleDisposable sample = new SampleDisposable(throwException: true);
SampleDisposable arg = sample;
TestLogMonitor logMonitor = new TestLogMonitor();
// ACT
logMonitor.StartLogging(filterByCurrentThread: true);
try {
DisposableUtil.ClearDisposableObject(ref arg);
} finally {
logMonitor.StopLogging();
}
// ASSERT
Assert.Equal(null, arg);
Assert.Equal(1, sample.DisposedCount);
LogEntry expectedEntry = new LogEntry(null, TraceEventType.Error, $"Fail to dispose the object at 'ClearDisposableObject.Error()': {sample.DisposeErrorMessage}");
logMonitor.AssertContains(expectedEntry);
}
private static void TestStrategyNoException(DisposeExceptionStrategy strategy, bool throwMain, bool throwDispose)
{
// No return value:
var disposable = new SampleDisposable(throwDispose);
disposable.Using(strategy, _ => RunMainLogic(throwMain));
Assert.IsTrue(disposable.WasDisposeCalled);
// With return value:
disposable = new SampleDisposable(throwDispose);
var result = disposable.Using(strategy, _ =>
{
RunMainLogic(throwMain);
return(42);
});
Assert.IsTrue(disposable.WasDisposeCalled);
Assert.AreEqual(42, result);
}
private static async Task TestStrategyNoExceptionAsync(DisposeExceptionStrategy strategy, bool throwMain, bool throwDispose)
{
// No return value:
var disposable = new SampleDisposable(throwDispose);
await disposable.UsingAsync(strategy, async _ => await RunMainLogicAsync(throwMain));
Assert.IsTrue(disposable.WasDisposeCalled);
// With return value:
disposable = new SampleDisposable(throwDispose);
var result = await disposable.UsingAsync(strategy, async _ =>
{
await RunMainLogicAsync(throwMain);
return(42);
});
Assert.IsTrue(disposable.WasDisposeCalled);
Assert.AreEqual(42, result);
}
public override bool IsNullValue(SampleDisposable item)
{
return(item == null);
}
