public async Task StartStop() {
var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
session.HostStarted.Should().NotBeCompleted();
session.IsHostRunning.Should().BeFalse();
await session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 50000);
session.HostStarted.Should().BeRanToCompletion();
session.IsHostRunning.Should().BeTrue();
await session.StopHostAsync();
session.HostStarted.Should().NotBeCompleted();
session.IsHostRunning.Should().BeFalse();
await session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 50000);
session.HostStarted.Should().BeRanToCompletion();
session.IsHostRunning.Should().BeTrue();
}
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 StartStop() {
var session = new RSession(0, null, () => { });
session.HostStarted.Status.Should().Be(TaskStatus.Canceled);
session.IsHostRunning.Should().BeFalse();
await session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name,
RBasePath = RUtilities.FindExistingRBasePath()
}, 50000);
session.HostStarted.Status.Should().Be(TaskStatus.RanToCompletion);
session.IsHostRunning.Should().BeTrue();
await session.StopHostAsync();
session.HostStarted.Status.Should().Be(TaskStatus.Canceled);
session.IsHostRunning.Should().BeFalse();
}
public async Task Start_KillProcess_Start() {
var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
session.HostStarted.Should().NotBeCompleted();
session.IsHostRunning.Should().BeFalse();
await session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 50000);
session.HostStarted.Should().BeRanToCompletion();
session.IsHostRunning.Should().BeTrue();
var sessionDisconnectedTask = EventTaskSources.IRSession.Disconnected.Create(session);
var processId = await GetRSessionProcessId(session);
Process.GetProcessById(processId).Kill();
await sessionDisconnectedTask;
session.IsHostRunning.Should().BeFalse();
await session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 50000);
session.HostStarted.Should().BeRanToCompletion();
session.IsHostRunning.Should().BeTrue();
}
public async Task StopReentrantLoop() {
var callback = new RSessionCallbackStub();
var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
await session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, callback, 50000);
var testMrs = new AsyncManualResetEvent();
callback.PlotHandler = (message, ct) => {
testMrs.Set();
return session.EvaluateAsync("x <- 1\n");
};
Task responceTask;
using (var interaction = await session.BeginInteractionAsync()) {
responceTask = interaction.RespondAsync("plot(1)\n");
}
await testMrs.WaitAsync().Should().BeCompletedAsync();
await session.StopHostAsync().Should().BeCompletedAsync(20000);
session.IsHostRunning.Should().BeFalse();
await responceTask.Should().BeCanceledAsync();
}
public async Task StopBeforeInitialized_RHostMissing() {
var brokerClient = new LocalBrokerClient(nameof(RSessionTest), @"C:\",
TestCoreServices.CreateReal(), new NullConsole(), Environment.SystemDirectory);
var session = new RSession(0, brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
Func<Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 10000);
var startTask = Task.Run(start).SilenceException<RHostBrokerBinaryMissingException>();
await session.StopHostAsync();
session.IsHostRunning.Should().BeFalse();
await startTask;
}
public async Task StopBeforeInitialized() {
var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
Func<Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 10000);
var startTask = Task.Run(start);
await session.StopHostAsync();
session.IsHostRunning.Should().BeFalse();
await startTask;
}
public void StartRHostMissing() {
var brokerClient = new LocalBrokerClient(nameof(RSessionTest), @"C:\", TestCoreServices.CreateReal(), new NullConsole(), Environment.SystemDirectory);
var session = new RSession(0, brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
Func<Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name
}, null, 10000);
start.ShouldThrow<RHostBrokerBinaryMissingException>();
}
public async Task StartStopMultipleSessions() {
Func<int, Task<RSession>> start = async i => {
var session = new RSession(i, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
await session.StartHostAsync(new RHostStartupInfo { Name = _testMethod.Name + i }, 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 DoubleStart() {
var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
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 StartStopMultipleSessions() {
Func<int, Task<RSession>> start = async i => {
var session = new RSession(i, null, () => { });
await session.StartHostAsync(new RHostStartupInfo { Name = _testMethod.Name, RBasePath = RUtilities.FindExistingRBasePath()}, 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 StopBeforeInitialized() {
var session = new RSession(0, null, () => { });
Func<Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name,
RHostDirectory = Environment.SystemDirectory
}, 10000);
Task.Run(start).DoNotWait();
await session.StopHostAsync();
session.IsHostRunning.Should().BeFalse();
}
public void StartRHostMissing() {
var session = new RSession(0, null, () => { });
Func<Task> start = () => session.StartHostAsync(new RHostStartupInfo {
Name = _testMethod.Name,
RHostDirectory = Environment.SystemDirectory
}, 10000);
start.ShouldThrow<RHostBinaryMissingException>();
}
