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}\""));
}
private async Task RunAsync(IXunitTestCase testCase, Func <Task> action, RunSummary runSummary, string timeoutMessage)
{
Exception exception = null;
_stopwatch.Restart();
try {
var task = action();
await ParallelTools.When(task, 60_000, timeoutMessage);
await task;
} catch (Exception ex) {
exception = ex;
}
_stopwatch.Stop();
var time = (decimal)_stopwatch.Elapsed.TotalSeconds;
var taskRunSummary = exception != null
? RegisterFailedRunSummary(testCase, time, exception)
: new RunSummary
{
Time = time
};
runSummary.Aggregate(taskRunSummary);
}
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 CanceledOnTimeout()
{
var tcs = new TaskCompletionSource <int>();
tcs.RegisterForCancellation(200, CancellationToken.None);
await ParallelTools.When(tcs.Task);
tcs.Task.Should().BeCanceled();
}
public void ParallelAccess()
{
using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
var guids = new[] { new Guid(), new Guid() };
ParallelTools.Invoke(100, i => {
var session = sessionProvider.GetOrCreate(guids[i % 2]);
session.Dispose();
});
}
}
public void ParallelAccess()
{
using (var sessionProvider = new RSessionProvider()) {
var guids = new[] { new Guid(), new Guid() };
ParallelTools.Invoke(100, i => {
var session = sessionProvider.GetOrCreate(guids[i % 2], _brokerConnector);
session.Dispose();
});
}
}
public void ParallelAccess()
{
using (var sessionProvider = new RSessionProvider(_services)) {
var guids = new[] { nameof(ParallelAccess) + 1, nameof(ParallelAccess) + 2 };
ParallelTools.Invoke(100, i => {
var session = sessionProvider.GetOrCreate(guids[i % 2]);
session.Dispose();
});
}
}
public async Task CanceledOnToken()
{
var tcs = new TaskCompletionSource <int>();
var cts = new CancellationTokenSource();
tcs.RegisterForCancellation(cts.Token);
cts.CancelAfter(200);
await ParallelTools.When(tcs.Task);
tcs.Task.Should().BeCanceled();
}
public async Task SwitchToTheSameBroker_NoSessions()
{
using (var sessionProvider = new RSessionProvider(_services)) {
var switch1Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker_NoSessions));
var switch2Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker_NoSessions));
await ParallelTools.WhenAll(30000, switch1Task, switch2Task);
switch1Task.Status.Should().Be(TaskStatus.RanToCompletion);
switch2Task.Status.Should().Be(TaskStatus.RanToCompletion);
}
}
private async Task InitializeGraphicsDevice()
{
var deviceCreatedTask = EventTaskSources.IRPlotManager.DeviceAdded.Create(_plotManager);
var deviceChangedTask = EventTaskSources.IRPlotManager.ActiveDeviceChanged.Create(_plotManager);
var eval = _workflow.ActiveWindow.InteractiveWindow.Evaluator;
var result = await eval.ExecuteCodeAsync("dev.new()\n");
result.IsSuccessful.Should().BeTrue();
await ParallelTools.WhenAll(20000, deviceCreatedTask, deviceChangedTask);
}
public void RHostPipeFuzzTest(int iteration)
{
ParallelTools.Invoke(1000, i => {
var input = GenerateInput();
try {
var message = Message.Parse(input);
var msgbytes = message.ToBytes();
} catch (InvalidDataException) {
} catch (TraceFailException) {
}
});
}
public async Task Invoke_Concurrent_ChangeAction()
{
var counts = new int[4];
var action = new DelayedAsyncAction(200);
ParallelTools.Invoke(4, i => {
action.Invoke(() => Task.FromResult(Interlocked.Increment(ref counts[i])));
});
await Task.Delay(400);
counts.Should().ContainSingle(i => i == 1, "DelayedAction should be called only once")
.And.OnlyContain(i => i <= 1, "DelayedAction should be called more than once");
}
public async Task SwitchAvailableLoadedInstalledAsync()
{
var t1 = InUI(() => _packageManagerViewModel.SwitchToAvailablePackagesAsync());
var t2 = InUI(() => _packageManagerViewModel.SwitchToLoadedPackagesAsync());
var t3 = InUI(() => _packageManagerViewModel.SwitchToInstalledPackagesAsync());
await ParallelTools.WhenAll(t1, t2, t3);
_packageManagerViewModel.IsLoading.Should().BeFalse();
_packageManagerViewModel.SelectedPackage.Should().NotBeNull();
_packageManagerViewModel.Items.Should().OnlyContain(o => ((IRPackageViewModel)o).IsInstalled)
.And.Contain(_packageManagerViewModel.SelectedPackage);
}
public async Task InvokeTwice_DuringTimeout_Concurrent()
{
var count = 0;
var action = new DelayedAsyncAction(200, () => Task.FromResult(Interlocked.Increment(ref count)));
ParallelTools.Invoke(4, async i => {
await Task.Delay(50 * i);
action.Invoke();
});
await Task.Delay(500);
count.Should().Be(1, "DelayedAction should be called only once");
}
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 void TrySetException()
{
var tcs = new TaskCompletionSourceEx <int>();
var count = 0;
ParallelTools.Invoke(8, i => {
var isSet = tcs.TrySetException(new Exception());
if (isSet)
{
Interlocked.Increment(ref count);
}
});
count.Should().Be(1);
}
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 SwitchLoadedInstalledAvailableAsync()
{
var t1 = InUI(() => _packageManagerViewModel.SwitchToLoadedPackagesAsync());
var t2 = InUI(() => _packageManagerViewModel.SwitchToInstalledPackagesAsync());
var t3 = InUI(() => _packageManagerViewModel.SwitchToAvailablePackagesAsync());
await ParallelTools.WhenAll(t1, t2, t3);
var expected = new [] { "NotAvailable1", "NotAvailable2", "rtvslib1" };
_packageManagerViewModel.IsLoading.Should().BeFalse();
_packageManagerViewModel.SelectedPackage.Should().NotBeNull();
_packageManagerViewModel.Items.Should().Equal(expected, (o, n) => ((IRPackageViewModel)o).Name.EqualsOrdinal(n))
.And.Contain(_packageManagerViewModel.SelectedPackage);
}
public async Task ExclusiveInteraction()
{
var interactionTasks = ParallelTools.Invoke(4, i => _session.BeginInteractionAsync());
IList <Task <IRSessionInteraction> > runningTasks = interactionTasks.ToList();
while (runningTasks.Count > 0)
{
await Task.WhenAny(runningTasks);
IList <Task <IRSessionInteraction> > completedTasks;
runningTasks.Split(t => t.Status == TaskStatus.RanToCompletion, out completedTasks, out runningTasks);
completedTasks.Should().ContainSingle();
completedTasks.Single().Result.Dispose();
}
}
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 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 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 ConnectWhenSwitching()
{
using (var sessionProvider = new RSessionProvider(_services)) {
var session1 = sessionProvider.GetOrCreate(nameof(ConnectWhenSwitching) + 1);
var session2 = sessionProvider.GetOrCreate(nameof(ConnectWhenSwitching) + 2);
var switchTask = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(ConnectWhenSwitching));
var startHost1Task = Task.Delay(50).ContinueWith(t => session1.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000)).Unwrap();
var startHost2Task = Task.Delay(100).ContinueWith(t => session2.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000)).Unwrap();
await ParallelTools.WhenAll(30000, switchTask, startHost1Task, startHost2Task);
startHost1Task.Should().BeRanToCompletion();
startHost2Task.Should().BeRanToCompletion();
await ParallelTools.WhenAll(30000, session1.HostStarted, session2.HostStarted);
}
}
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 SwitchToTheSameBroker()
{
using (var sessionProvider = new RSessionProvider(_services)) {
var session = sessionProvider.GetOrCreate(nameof(SwitchToTheSameBroker));
session.RestartOnBrokerSwitch = true;
await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker));
await session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000);
var switch1Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker) + "1");
var switch2Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker) + "1");
await ParallelTools.WhenAll(30000, switch1Task, switch2Task);
switch1Task.Status.Should().Be(TaskStatus.RanToCompletion);
switch2Task.Status.Should().Be(TaskStatus.RanToCompletion);
}
}
public async Task ConnectWhenSwitching_SwitchFailed()
{
using (var sessionProvider = new RSessionProvider(_services)) {
await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(ConnectWhenSwitching_SwitchFailed));
var switchTask = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(ConnectWhenSwitching_SwitchFailed) + "1", BrokerConnectionInfo.Create(null, "JHFFR", @"\\JHF\F\R"));
await Task.Yield();
var session = sessionProvider.GetOrCreate(nameof(ConnectWhenSwitching_SwitchFailed));
var startHostTask = session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000);
await ParallelTools.WhenAll(30000, switchTask, startHostTask);
startHostTask.Should().BeRanToCompletion();
switchTask.Should().BeRanToCompletion();
switchTask.Result.Should().BeFalse();
}
}
