public async Task RunAsync_SubProcessListSupplied_AllAreRun(int processCount)
{
// arrange
var processId = 0;
var expectedKeys = Enumerable.Range(1, processCount);
var dict = new ConcurrentDictionary <int, DateTime>();
_fixture.Register(() =>
{
var process = A.Fake <IProcess>();
A.CallTo(() => process.RunAsync(CancellationToken.None)).ReturnsLazily(() =>
{
var id = Interlocked.Increment(ref processId);
dict.TryAdd(id, DateTime.Now);
return(Task.CompletedTask);
});
return(process);
});
var processes = _fixture.CreateMany <IProcess>(processCount);
var sut = new ParallelProcess(processes);
// act
await sut.RunAsync(CancellationToken.None);
// assert
dict.Should().ContainKeys(expectedKeys);
}
public void TaskSample()
{
Console.WriteLine("Task");
Console.WriteLine("====");
ParallelProcess parallelProcess = new ParallelProcess();
Task[] tasks = new Task[2];
string taskName01 = "Tarea 01";
string taskName02 = "Tarea 02";
tasks[0] = Task.Factory.StartNew((Object obj) => {
TaskParameter param = (TaskParameter)obj;
parallelProcess.WriteProcess01(param.Name);
}, new TaskParameter {
Name = taskName01
});
tasks[1] = Task.Factory.StartNew((Object obj) => {
TaskParameter param = (TaskParameter)obj;
parallelProcess.WriteProcess02(param.Name);
}, new TaskParameter {
Name = taskName02
});
Task.WaitAll(tasks);
}
public void RunAsync_NoProcessesToRun_NoExceptions()
{
// arrange
var sut = new ParallelProcess();
// act + assert
sut.Invoking(async process => await process.RunAsync(CancellationToken.None))
.Should().NotThrow();
}
public void Create_ListOfProcesses_ShouldContainSameProcesses()
{
// arrange
var subProcesses = _fixture.CreateMany <IProcess>().ToArray();
var sut = new ParallelProcess();
// act
var process = sut.Create(subProcesses);
// assert
process.Should().BeEquivalentTo(subProcesses);
}
public void ThreadSample()
{
Console.WriteLine("Thread");
Console.WriteLine("======");
ParallelProcess parallelProcess = new ParallelProcess();
Thread th1 = new Thread(new ThreadStart(parallelProcess.WriteProcess01));
Thread th2 = new Thread(new ThreadStart(parallelProcess.WriteProcess02));
th1.Start();
th2.Start();
th1.Join();
th2.Join();
}
public async Task RunAsync_ManyProcesses_RunInParallel(int processCount)
{
// arrange
var processIdCounter = 0;
var runOrder = new BlockingCollection <int>(processCount);
var parallelProcessCounter = 0;
var maxProcessesRunningInParallel = 0;
var randomizer = new Random(Environment.TickCount);
_fixture.Register(() =>
{
var process = A.Fake <IProcess>();
var processId = Interlocked.Increment(ref processIdCounter);
A.CallTo(() => process.RunAsync(CancellationToken.None)).ReturnsLazily(async() =>
{
var runningProcesses = Interlocked.Increment(ref parallelProcessCounter);
maxProcessesRunningInParallel = Math.Max(runningProcesses, maxProcessesRunningInParallel);
await Task.Delay(randomizer.Next(minValue: 1, maxValue: 100));
runOrder.Add(processId);
Interlocked.Decrement(ref parallelProcessCounter);
});
return(process);
});
var processes = _fixture.CreateMany <IProcess>(processCount);
var sut = new ParallelProcess(processes);
// act
await sut.RunAsync(CancellationToken.None);
// assert
maxProcessesRunningInParallel.Should().BeGreaterOrEqualTo(2);
runOrder.Should().HaveCount(processCount);
runOrder.Should().NotBeAscendingInOrder();
}
public void RunAsync_ManyProcessesThrows_ThrowsAggregateExceptionForProcesses(int processCount)
{
// arrange
var counter = 0;
_fixture.Register(() =>
{
var processId = Interlocked.Increment(ref counter);
var expectedException = new Exception($"I'm failing You, I'm so sorry. Process id: {processId}.");
var process = A.Fake <IProcess>();
A.CallTo(() => process.RunAsync(CancellationToken.None)).Returns(Task.FromException(expectedException));
return(process);
});
var processes = _fixture.CreateMany <IProcess>(processCount);
var sut = new ParallelProcess(processes);
// act + assert
sut.Invoking(async x => await x.RunAsync(CancellationToken.None))
.Should().Throw <AggregateException>().Where(ex => ex.InnerExceptions.Count == processCount);
}
public ParallelProcessRegistered(ParallelProcess <TResult> parent)
{
Parent = parent;
}
