public void Dispose_Wait_Running_Or_Queued_Tasks()
{
// arrange
TestResource testResource = new TestResource();
SharedResource <TestResource> sharedResource = new SharedResource <TestResource>
(
resource: testResource,
maxConcurrentUserCount: 1,
isMaxConcurrentUserCountReadOnly: true
);
// act
const int taskCount = 1000;
Task[] tasks = new Task[taskCount];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = sharedResource.UseAsync(p => p.Resource.IncreaseCounterNoThreadSafe());
}
sharedResource.Dispose();
testResource.WaitUntilDisposedFor5Minutes();
// assert
Assert.IsTrue(testResource.IsDisposed);
Assert.IsTrue(testResource.Counter == taskCount);
}
public static void Test()
{
int called = 0;
Action dispose = () => called++;
//Make sure the mock IDisposable class works the way it's supposed to
using (new GenericDisposable(dispose))
{
Assert.That(called, Is.EqualTo(0));
}
Assert.That(called, Is.EqualTo(1));
called = 0;
SharedResource <GenericDisposable> s1 = null;
SharedResource <GenericDisposable> s2 = null;
try
{
s1 = new SharedResource <GenericDisposable>(() => new GenericDisposable(dispose));
Assert.That(called, Is.EqualTo(0));
s2 = s1.Copy();
Assert.That(called, Is.EqualTo(0));
s1.Dispose();
s1 = null;
Assert.That(called, Is.EqualTo(0));
s2.Dispose();
s2 = null;
Assert.That(called, Is.EqualTo(1));
}
finally
{
if (s1 != null)
{
s1.Dispose();
}
if (s2 != null)
{
s2.Dispose();
}
}
}
public void Dispose_Ignores_Running_Or_Queued_Tasks_That_Canceled_Or_Faulted()
{
// arrange
TestResource testResource = new TestResource();
SharedResource <TestResource> sharedResource = new SharedResource <TestResource>
(
resource: testResource,
maxConcurrentUserCount: 1,
isMaxConcurrentUserCountReadOnly: true
);
// act
const int taskCount = 1000;
Task[] tasks = new Task[taskCount];
int normalTaskCount = 0;
for (int i = 0; i < tasks.Length; i++)
{
int switchFactor = i % 3;
if (switchFactor != 0 && switchFactor != 1)
{
normalTaskCount++;
}
CancellationTokenSource tokenSource = new CancellationTokenSource();
tasks[i] = sharedResource.UseAsync(p =>
{
switch (switchFactor)
{
case 0:
throw new InvalidOperationException("Test Exception");
case 1:
tokenSource.Cancel();
tokenSource.Token.ThrowIfCancellationRequested();
break;
default:
p.Resource.IncreaseCounterNoThreadSafe();
break;
}
},
tokenSource.Token);
}
sharedResource.Dispose();
testResource.WaitUntilDisposedFor5Minutes();
// assert
Assert.IsTrue(testResource.IsDisposed);
Assert.IsTrue(testResource.Counter == normalTaskCount);
}
public void Disposed_Resource_Throws_Exception_When_Try_To_Use()
{
// arrange
SharedResource <TestResource> sharedResource = new SharedResource <TestResource>
(
resource: new TestResource(),
maxConcurrentUserCount: 1,
isMaxConcurrentUserCountReadOnly: true
);
// act
sharedResource.Dispose();
Exception cachedException = null;
try { sharedResource.UseAsync(i => i.Resource.IncreaseCounter()); }
catch (Exception e) { cachedException = e; }
// assert
Assert.IsNotNull(cachedException);
Assert.IsTrue(cachedException.Message == "This shared resource is already disposed.");
}
public void Dispose_Disposes_Resource()
{
// arrange
TestResource testResource = new TestResource();
SharedResource <TestResource> sharedResource = new SharedResource <TestResource>
(
resource: testResource,
maxConcurrentUserCount: 1,
isMaxConcurrentUserCountReadOnly: true
);
// act
Task task = sharedResource.UseAsync(p => p.Resource.IncreaseCounterNoThreadSafe());
sharedResource.Dispose();
testResource.WaitUntilDisposedFor5Minutes();
// assert
Assert.IsTrue(testResource.IsDisposed);
Assert.IsTrue(testResource.Counter == 1);
}
