private static TimeSpan PerformUsingSolidControl(Action[] operations, ConcurrencyControlMode mode)
{
var tasks = new Task[operations.Length];
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
using (var control = ConcurrencyControl.New(mode))
{
for (var i = 0; i < operations.Length; i++)
{
var operation = operations[i];
tasks[i] = Task.Factory.StartNew(() =>
{
using (var controlToken = control.Enter())
{
operation();
}
});
}
Task.WaitAll(tasks);
}
}
finally
{
stopwatch.Stop();
}
return(stopwatch.Elapsed);
}
public void New_ShouldReturnValidResult_ForSingleThreadLockMode()
{
// Arrange.
var mode = ConcurrencyControlMode.SingleThreadLock;
// Act.
using (var target = ConcurrencyControl.New(mode))
{
// Assert.
target.Should().NotBeNull();
target.Should().BeOfType <SingleThreadLockControl>();
}
}
public void New_ShouldReturnValidResult_ForProcessorCountSemaphoreMode()
{
// Arrange.
var mode = ConcurrencyControlMode.ProcessorCountSemaphore;
// Act.
using (var target = ConcurrencyControl.New(mode))
{
// Assert.
target.Should().NotBeNull();
target.Should().BeOfType <ProcessorCountSemaphoreControl>();
}
}
public void New_ShouldReturnValidResult_ForUnconstrainedMode()
{
// Arrange.
var mode = ConcurrencyControlMode.Unconstrained;
// Act.
using (var target = ConcurrencyControl.New(mode))
{
// Assert.
target.Should().NotBeNull();
target.Should().BeOfType <UnconstrainedControl>();
}
}
public void New_ShouldRaiseArgumentOutOfRangeException_ForUnspecifiedModeArgument()
{
// Arrange.
var mode = ConcurrencyControlMode.Unspecified;
var blockTimeoutThreshold = Timeout.InfiniteTimeSpan;
// Act.
var action = new Action(() =>
{
using (var target = ConcurrencyControl.New(mode, blockTimeoutThreshold))
{
return;
}
});
// Assert.
action.Should().Throw <ArgumentOutOfRangeException>();
}
public void New_ShouldRaiseArgumentOutOfRangeException_ForNegativeBlockTimeoutThresholdArgument()
{
// Arrange.
var mode = ConcurrencyControlMode.DuplexSemaphore;
var blockTimeoutThreshold = TimeSpan.FromDays(-1);
// Act.
var action = new Action(() =>
{
using (var target = ConcurrencyControl.New(mode, blockTimeoutThreshold))
{
return;
}
});
// Assert.
action.Should().Throw <ArgumentOutOfRangeException>();
}
public void AttachTask_ShouldCompleteTasksAsynchronously()
{
// Arrange.
var mode = ConcurrencyControlMode.Unconstrained;
var completionRecords = new List <Int32>();
using (var control = ConcurrencyControl.New(mode))
{
using (var target = control.Enter())
{
// Act.
target.AttachTask(Delay(800, completionRecords));
target.AttachTask(Delay(0, completionRecords));
target.AttachTask(Delay(400, completionRecords));
}
}
// Assert.
completionRecords.ElementAt(0).Should().Be(0);
completionRecords.ElementAt(1).Should().Be(400);
completionRecords.ElementAt(2).Should().Be(800);
}
internal static void FunctionalLifeSpanTest_ShouldProduceDesiredResults(ConcurrencyControlMode mode)
{
// Arrange.
var operationCount = 30;
var operations = new Action[operationCount];
var tasks = new Task[operationCount];
InitializeOperations(operations);
// Act.
var action = new Action(() =>
{
using (var target = ConcurrencyControl.New(mode))
{
for (var i = 0; i < operationCount; i++)
{
var operation = operations[i];
tasks[i] = Task.Factory.StartNew(() =>
{
using (var controlToken = target.Enter())
{
controlToken.IsActive.Should().BeTrue();
operation();
controlToken.Release();
controlToken.IsActive.Should().BeFalse();
}
});
}
Task.WaitAll(tasks);
}
});
// Assert.
action.Should().NotThrow();
}
internal virtual IConcurrencyControl InitializeStateControl() => ConcurrencyControl.New(StateControlMode, StateControlTimeoutThreshold);
