private RSession CreateRSession(string sessionId) { var session = new RSession(Interlocked.Increment(ref _sessionCounter), sessionId, Broker, _connectArwl.CreateExclusiveReaderLock(), () => DisposeSession(sessionId)); session.Connected += RSessionOnConnected; return(session); }
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 CancelAll(TestMethodFixture testMethod, TaskObserverMethodFixture taskObserver) { _taskObserver = taskObserver; _testMethod = testMethod.MethodInfo; _brokerClient = CreateLocalBrokerClient(nameof(RSessionTest) + nameof(CancelAll)); _callback = new RSessionCallbackStub(); _session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => {}); }
private RSession CreateRSession(Guid guid) { var session = new RSession(Interlocked.Increment(ref _sessionCounter), Broker, () => DisposeSession(guid)); session.Connected += RSessionOnConnected; session.Disconnected += RSessionOnDisconnected; return(session); }
public async Task CreateBlob_DisconnectedFromTheStart() { using (var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { })) { var data = new byte[] { 1, 2, 3, 4, 5 }; using (DataTransferSession dts = new DataTransferSession(session, null)) { Func<Task> f = () => dts.SendBytesAsync(data, false, null, CancellationToken.None); await f.ShouldThrowAsync<RHostDisconnectedException>(); } } }
public void Lifecycle() { var disposed = false; var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => disposed = true); disposed.Should().BeFalse(); session.MonitorEvents(); session.Dispose(); session.ShouldRaise("Disposed"); disposed.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 void Lifecycle() { var disposed = false; var session = new RSession(0, null, () => disposed = true); disposed.Should().BeFalse(); session.MonitorEvents(); session.Dispose(); session.ShouldRaise("Disposed"); disposed.Should().BeTrue(); disposed = false; session.MonitorEvents(); session.Dispose(); session.ShouldNotRaise("Disposed"); disposed.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 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 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 CancelAll(TestMethodFixture testMethod) { _testMethodFixture = testMethod; _testMethod = testMethod.MethodInfo; _session = new RSession(0, null, () => {}); }
public BeforeInitializedRExpressionEvaluator(RSession session) { _session = session; }
public async Task BeginInteractionAsync_DisconnectedFromTheStart() { using (var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { })) { // ReSharper disable once AccessToDisposedClosure Func<Task> f = () => session.BeginInteractionAsync(); await f.ShouldThrowAsync<RHostDisconnectedException>(); } }
public InteractionEvaluation(TestMethodFixture testMethod) { _testMethod = testMethod.Method; _session = new RSession(0, null, () => {}); }
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>(); }
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 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 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 DestroyBlob_DisconnectedFromTheStart() { using (var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { })) { var blobids = new ulong[] { 1, 2, 3, 4, 5 }; Func<Task> f = () => session.DestroyBlobsAsync(blobids); await f.ShouldThrowAsync<RHostDisconnectedException>(); } }
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 GetBlob_DisconnectedFromTheStart() { using (var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { })) { Func<Task> f = () => session.BlobReadAllAsync(1); await f.ShouldThrowAsync<RHostDisconnectedException>(); } }
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>(); }
private RSession CreateRSession(Guid guid) { var session = new RSession(Interlocked.Increment(ref _sessionCounter), Broker, _connectArwl.CreateExclusiveReaderLock(), () => DisposeSession(guid)); session.Connected += RSessionOnConnected; return session; }
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 InteractionEvaluation(TestMethodFixture testMethod, TaskObserverMethodFixture taskObserver) { _taskObserver = taskObserver; _testMethod = testMethod.MethodInfo; _brokerClient = CreateLocalBrokerClient(nameof(RSessionTest) + nameof(InteractionEvaluation)); _session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { }); }
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 BrokerTransaction(RSession session) { _session = session; }
public Output(TestMethodFixture testMethod) { _testMethod = testMethod.MethodInfo; _brokerClient = CreateLocalBrokerClient(nameof(RSessionTest) + nameof(Output)); _session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { }); }