public async Task ConcurrentRequests()
{
var responds = new ConcurrentQueue <int>();
var input = new ConcurrentQueue <string>();
var output = new ConcurrentQueue <string>();
void OutputHandler(object o, ROutputEventArgs e) => output.Enqueue(e.Message);
Task <string> InputHandler(string prompt, int maximumLength, CancellationToken ct)
{
input.Enqueue(prompt);
return(Task.FromResult($"{prompt}\n"));
}
_callback.ReadUserInputHandler = InputHandler;
_session.Output += OutputHandler;
await ParallelTools.InvokeAsync(10, async i => {
using (var interaction = await _session.BeginInteractionAsync()) {
responds.Enqueue(i);
await interaction.RespondAsync($"readline('{i}')");
}
}, 20000);
_session.Output -= OutputHandler;
responds.Should().BeEquivalentTo(Enumerable.Range(0, 10));
input.Should().Equal(responds.Select(i => i.ToString()));
output.Should().Contain(responds.Select(i => $" \"{i}\""));
}
public async Task StartStopMultipleSessions()
{
Func <int, Task <RSession> > start = async i => {
var session = new RSession(i, _brokerClient, () => { });
await session.StartHostAsync(new RHostStartupInfo { Name = _testMethod.Name + i }, null, 50000);
return(session);
};
var sessionsTasks = await ParallelTools.InvokeAsync(4, start);
if (sessionsTasks.Any(t => t.Status != TaskStatus.RanToCompletion))
{
Debugger.Launch();
}
sessionsTasks.Should().OnlyContain(t => t.Status == TaskStatus.RanToCompletion);
var sessions = sessionsTasks.Select(t => t.Result).ToList();
sessions.Should().OnlyContain(t => t.IsHostRunning);
var sessionStopTasks = await ParallelTools.InvokeAsync(4, i => sessionsTasks[i].Result.StopHostAsync());
sessionStopTasks.Should().OnlyContain(t => t.Status == TaskStatus.RanToCompletion);
sessions.Should().OnlyContain(t => !t.IsHostRunning);
}
public async Task Concurrent_Write_ReadCanceled()
{
var writersCount = 0;
await ParallelTools.InvokeAsync(48, async i => {
// Every 4th lock is writer lock
var isWriter = i % 4 == 0;
if (isWriter)
{
var task = _arwl.WriterLockAsync(CancellationToken.None);
using (await task) {
var count = writersCount;
await Task.Delay(20, CancellationToken.None);
// CompareExchange won't work if lock wasn't exclusive
Interlocked.CompareExchange(ref writersCount, count + 1, count);
}
return(task);
}
else
{
var cts = new CancellationTokenSource();
var task = _arwl.ReaderLockAsync(cts.Token);
cts.Cancel();
if (!task.IsCanceled)
{
(await task).Dispose();
}
return(task);
}
});
writersCount.Should().Be(12);
}
public async Task CancelAllInParallel()
{
Task responceTask;
using (var interaction = await _session.BeginInteractionAsync()) {
responceTask = interaction.RespondAsync("while(TRUE){}\n");
}
await ParallelTools.InvokeAsync(4, i => _session.CancelAllAsync());
_session.IsHostRunning.Should().BeTrue();
responceTask.Status.Should().Be(TaskStatus.Canceled);
}
public async Task Concurrent_Write()
{
var writersCount = 0;
await ParallelTools.InvokeAsync(12, async i => {
using (await _arwl.WriterLockAsync()) {
var count = writersCount;
await Task.Delay(20);
// CompareExchange won't work it lock wasn't exclusive
Interlocked.CompareExchange(ref writersCount, count + 1, count);
}
});
writersCount.Should().Be(12);
}
public async Task Release()
{
var bal = new BinaryAsyncLock();
var count = 0;
await ParallelTools.InvokeAsync(4, async i => {
var isSet = await bal.WaitAsync();
if (!isSet)
{
Interlocked.Increment(ref count);
bal.Release();
}
});
count.Should().Be(1);
}
public async Task WaitAsync_SetInCtor()
{
var bal = new BinaryAsyncLock(true);
var count = 0;
await ParallelTools.InvokeAsync(4, async i => {
await bal.WaitAsync();
if (!bal.IsSet)
{
await Task.Delay(50);
Interlocked.Increment(ref count);
}
});
count.Should().Be(0);
}
public async Task WaitAsync_Reset()
{
var bal = new BinaryAsyncLock();
var count = 0;
await ParallelTools.InvokeAsync(4, async i => {
var token = await bal.WaitAsync();
if (!bal.IsSet)
{
await Task.Delay(50);
Interlocked.Increment(ref count);
token.Reset();
}
});
count.Should().Be(4);
}
public async Task ExclusiveEvaluation()
{
var interactionTasks = await ParallelTools.InvokeAsync(4, i => Task.Factory.StartNew(() => _session.BeginEvaluationAsync()));
IList <Task <IRSessionEvaluation> > runningTasks = interactionTasks.ToList();
while (runningTasks.Count > 0)
{
await Task.WhenAny(runningTasks);
IList <Task <IRSessionEvaluation> > completedTasks;
runningTasks.Split(t => t.Status == TaskStatus.RanToCompletion, out completedTasks, out runningTasks);
completedTasks.Should().ContainSingle();
completedTasks.Single().Result.Dispose();
}
}
public async Task ConcurrentRequests()
{
var output = new List <string>();
EventHandler <ROutputEventArgs> outputHandler = (o, e) => output.Add(e.Message);
_callback.ReadUserInputHandler = (m, l, c) => Task.FromResult($"{m}\n");
await ParallelTools.InvokeAsync(10, async i => {
using (var interaction = await _session.BeginInteractionAsync()) {
_session.Output += outputHandler;
await interaction.RespondAsync($"readline('{i}')");
_session.Output -= outputHandler;
}
});
output.Should().Contain(Enumerable.Range(0, 10).Select(i => $" \"{i}\""));
}
public async Task DoubleStart()
{
var session = new RSession(0, _testMethod.FileSystemSafeName, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
Func <Task> start = () => session.StartHostAsync(new RHostStartupInfo(), null, 50000);
var tasks = await ParallelTools.InvokeAsync(4, i => start(), 50000);
tasks.Should().ContainSingle(t => t.Status == TaskStatus.RanToCompletion);
await session.HostStarted;
session.IsHostRunning.Should().BeTrue();
await session.StopHostAsync();
session.IsHostRunning.Should().BeFalse();
}
public async Task StartStopMultipleSessions()
{
Func <int, Task <RSession> > start = async i => {
var session = new RSession(i, () => { });
await session.StartHostAsync(new RHostStartupInfo { Name = _testMethod.Name, RBasePath = RUtilities.FindExistingRBasePath() }, null, 50000);
return(session);
};
var sessions = await ParallelTools.InvokeAsync(4, start);
sessions.Should().OnlyContain(s => s.IsHostRunning);
await ParallelTools.InvokeAsync(4, i => sessions[i].StopHostAsync());
sessions.Should().OnlyContain(s => !s.IsHostRunning);
}
public async Task Concurrent_ReadWriteRead_CancelSecond()
{
var task = _arwl.ReaderLockAsync(CancellationToken.None);
var tasks = await ParallelTools.InvokeAsync(12, i => {
var cts = new CancellationTokenSource();
var task1 = _arwl.WriterLockAsync(cts.Token);
var task2 = _arwl.ReaderLockAsync(CancellationToken.None);
cts.Cancel();
return(new[] { task1, task2 });
}, Task.WhenAll);
task.Should().BeRanToCompletion();
foreach (var taskPair in tasks)
{
taskPair[0].Should().BeCanceled();
taskPair[1].Should().BeRanToCompletion();
}
}
public async Task DoubleStart()
{
var session = new RSession(0, _brokerConnector, () => { });
Func <Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 50000);
Func <Task> f = () => ParallelTools.InvokeAsync(4, i => start());
f.ShouldThrow <InvalidOperationException>();
await session.HostStarted;
session.IsHostRunning.Should().BeTrue();
await session.StopHostAsync();
session.IsHostRunning.Should().BeFalse();
}
public async Task DoubleStart()
{
var session = new RSession(0, _brokerClient, () => { });
Func <Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 50000);
var tasks = await ParallelTools.InvokeAsync(4, i => start(), 50000);
tasks.Should().ContainSingle(t => t.Status == TaskStatus.RanToCompletion);
await session.HostStarted;
session.IsHostRunning.Should().BeTrue();
await session.StopHostAsync();
session.IsHostRunning.Should().BeFalse();
}
public async Task Reset()
{
var bal = new BinaryAsyncLock();
var count = 0;
await ParallelTools.InvokeAsync(4, async i => {
try {
var isSet = await bal.WaitAsync();
if (!isSet)
{
await Task.Delay(50);
bal.Reset();
}
} catch (OperationCanceledException) {
Interlocked.Increment(ref count);
}
});
count.Should().Be(3);
}
public async Task DoubleStart()
{
var session = new RSession(0, null, () => { });
Func <Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name,
RBasePath = RUtilities.FindExistingRBasePath()
}, 50000);
Func <Task> f = () => ParallelTools.InvokeAsync(4, i => start());
f.ShouldThrow <InvalidOperationException>();
await session.HostStarted;
session.IsHostRunning.Should().BeTrue();
await session.StopHostAsync();
session.IsHostRunning.Should().BeFalse();
}
public async Task StartStopMultipleSessions()
{
Func <int, Task <RSession> > start = async i => {
var session = new RSession(i, _testMethod.FileSystemSafeName + i, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
await session.StartHostAsync(new RHostStartupInfo(), null, 50000);
return(session);
};
var sessionsTasks = await ParallelTools.InvokeAsync(4, start, 50000);
sessionsTasks.Should().OnlyContain(t => t.Status == TaskStatus.RanToCompletion);
var sessions = sessionsTasks.Select(t => t.Result).ToList();
sessions.Should().OnlyContain(t => t.IsHostRunning);
var sessionStopTasks = await ParallelTools.InvokeAsync(4, i => sessionsTasks[i].Result.StopHostAsync());
sessionStopTasks.Should().OnlyContain(t => t.Status == TaskStatus.RanToCompletion);
sessions.Should().OnlyContain(t => !t.IsHostRunning);
}
public async Task Concurrent_ReadWrite()
{
var writersCount = 0;
await ParallelTools.InvokeAsync(48, async i => {
// Every 4th lock is writer lock
var isWriter = i % 4 == 3;
if (isWriter)
{
using (await _arwl.WriterLockAsync()) {
var count = writersCount;
await Task.Delay(20);
// CompareExchange won't work it lock wasn't exclusive
Interlocked.CompareExchange(ref writersCount, count + 1, count);
}
}
else
{
using (await _arwl.ReaderLockAsync()) { }
}
}, 50000);
writersCount.Should().Be(12);
}
