public void TestDisposedOnce()
{
MyDisposable o = new MyDisposable();
using (o)
{
Assert.AreEqual(0, o._disposedCount);
o.Dispose();
Assert.AreEqual(1, o._disposedCount);
o.Dispose();
Assert.AreEqual(1, o._disposedCount);
}
Assert.AreEqual(1, o._disposedCount);
}
public void TestDisposedOnce()
{
MyDisposable o = new MyDisposable();
using (o)
{
Assert.AreEqual(0, o._disposedCount);
o.Dispose();
Assert.AreEqual(1, o._disposedCount);
o.Dispose();
Assert.AreEqual(1, o._disposedCount);
}
Assert.AreEqual(1, o._disposedCount);
}
public void TestAssertWhenDisposed()
{
MyDisposable o = new MyDisposable();
o.Dispose();
o.TestAssert();
}
public void TestDisposedEvent()
{
MyDisposable o = new MyDisposable();
bool disposed = false;
o.Disposed += delegate { disposed = true; };
o.Dispose();
Assert.IsTrue(disposed, "Disposed event failed.");
}
public void TestDisposedEvent()
{
MyDisposable o = new MyDisposable();
bool disposed = false;
o.Disposed += delegate { disposed = true; };
o.Dispose();
Assert.IsTrue(disposed, "Disposed event failed.");
}
static void Main()
{
Console.WriteLine("* Fun with Dispose *");
MyDisposable obj = new MyDisposable();
obj.DoSomething();
obj.Dispose();
}
public void TestRemoveDisposedEvent()
{
MyDisposable o = new MyDisposable();
bool disposed = false;
EventHandler handler = delegate { disposed = true; };
o.Disposed += handler;
o.Disposed -= handler;
o.Dispose();
Assert.IsFalse(disposed, "Disposed fired?");
}
public void TestRemoveDisposedEvent()
{
MyDisposable o = new MyDisposable();
bool disposed = false;
EventHandler handler = delegate { disposed = true; };
o.Disposed += handler;
o.Disposed -= handler;
o.Dispose();
Assert.IsFalse(disposed, "Disposed fired?");
}
public void ObjectTarget_ShouldNotDisposeByDefault()
{
var myDisposable = new MyDisposable();
var targets = CreateTargetContainer();
targets.RegisterObject(myDisposable);
var container = CreateContainer(targets);
using (var scope = container.CreateScope())
{
var instance = scope.Resolve <MyDisposable>();
}
myDisposable.Dispose();
}
public IActionResult Privacy()
{
using (var disposal = new MyDisposable())
{
}
MyDisposable myObject = null;
try
{
myObject = new MyDisposable();
}
finally
{
myObject?.Dispose();
}
return(View());
}
public void TestDisposeList()
{
Semaphore s = new Semaphore(0, 100);
// Create object
MyDisposable disp = new MyDisposable()
.AddDisposeAction(d => s.Release(), s);
//
Assert.IsFalse(s.WaitOne(100));
Assert.IsFalse(disp.IsDisposeCalled);
Assert.IsFalse(disp.IsDisposing);
Assert.IsFalse(disp.IsDisposed);
disp.Dispose();
Assert.IsTrue(s.WaitOne(1000));
Assert.IsTrue(disp.IsDisposeCalled);
Assert.IsTrue(disp.IsDisposing);
Assert.IsTrue(disp.IsDisposed);
}
public void TestMethod1()
{
MyDisposable target = null;
try
{
target = new MyDisposable();
}
finally
{
if (target != null)
{
target.Dispose();
}
}
using (MyDisposable target2 = new MyDisposable())
{
}
}
public void TestBelateDispose()
{
Semaphore s = new Semaphore(0, 100);
// Create object
MyDisposable disp = new MyDisposable();
// Belate dispose, this handle is passed to the task
IDisposable belateHandle = disp.BelateDispose();
// Start work
Task.Run(() =>
{
// Do work
Thread.Sleep(1000);
//
Assert.IsFalse(disp.IsDisposing);
Assert.IsTrue(disp.IsDisposeCalled);
// Release belate handle
belateHandle.Dispose();
// Check is disposed
Assert.IsTrue(disp.IsDisposed);
//
s.Release();
});
// Start dispose, which is postponed
disp.Dispose();
// Check is disposed
Assert.IsTrue(disp.IsDisposeCalled);
Assert.IsFalse(disp.IsDisposed);
Assert.IsFalse(disp.IsDisposing);
// The test exists before the thread
s.WaitOne();
Assert.IsTrue(disp.IsDisposeCalled);
Assert.IsTrue(disp.IsDisposing);
Assert.IsTrue(disp.IsDisposed);
}
public void ObjectTarget_ShouldNotDisposeMultipleTimes()
{
var myDisposable = new MyDisposable();
var targets = CreateTargetContainer();
targets.RegisterObject(myDisposable, scopeBehaviour: ScopeBehaviour.Explicit);
;
using (var container = CreateScopedContainer(targets))
{
using (var childScope = container.CreateScope())
{
var instance = childScope.Resolve <MyDisposable>();
//should not dispose here when scope is disposed because
//we default to the root scope.
//if it does, then when instance2 is disposed we'll get an exception we're not expecting
}
var instance2 = container.Resolve <MyDisposable>();
//should dispose here when root scope is disposed
}
//should already be disposed here.
Assert.Throws <ObjectDisposedException>(() => myDisposable.Dispose());
}
public void TestAssertWhenDisposed()
{
MyDisposable o = new MyDisposable();
o.Dispose();
o.TestAssert();
}
