예제 #1
0
 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();
         });
     }
 }
예제 #2
0
        public async Task SwitchToTheSameBroker_NoSessions()
        {
            using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
                var switch1Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker));
                var switch2Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker));
                await Task.WhenAll(switch1Task, switch2Task);

                switch1Task.Status.Should().Be(TaskStatus.RanToCompletion);
                switch2Task.Status.Should().Be(TaskStatus.RanToCompletion);
            }
        }
예제 #3
0
        public void Lifecycle()
        {
            var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal());
            // ReSharper disable once AccessToDisposedClosure
            Action a = () => sessionProvider.GetOrCreate(new Guid());

            a.ShouldNotThrow();

            sessionProvider.Dispose();
            a.ShouldThrow <InvalidOperationException>();
        }
예제 #4
0
        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);
            }
        }
예제 #5
0
        public void Lifecycle()
        {
            var sessionProvider = new RSessionProvider(_services);
            // ReSharper disable once AccessToDisposedClosure
            Action a = () => sessionProvider.GetOrCreate(nameof(Lifecycle));

            a.ShouldNotThrow();

            sessionProvider.Dispose();
            a.ShouldThrow <InvalidOperationException>();
        }
예제 #6
0
        public void Lifecycle()
        {
            var sessionProvider = new RSessionProvider();
            // ReSharper disable once AccessToDisposedClosure
            Action a = () => sessionProvider.GetOrCreate(new Guid(), _brokerConnector);

            a.ShouldNotThrow();

            sessionProvider.Dispose();
            a.ShouldThrow <InvalidOperationException>();
        }
예제 #7
0
        private IRInteractiveWorkflow CreateRInteractiveWorkflow()
        {
            var sessionProvider = new RSessionProvider(_services, new InteractiveWindowConsole(_shell, _instanceLazy));
            var workflow        = new RInteractiveWorkflow(sessionProvider, _connectionsProvider, _historyProvider, _packagesProvider,
                                                           _plotsProvider, _activeTextViewTracker, _debuggerModeTracker,
                                                           _shell, _settings, _wss, () => DisposeInstance(sessionProvider));

            _disposableBag.Add(workflow);

            sessionProvider.BrokerChanging += OnBrokerChanging;
            return(workflow);
        }
예제 #8
0
        public async Task ConnectToRemote()
        {
            using (var sessionProvider = new RSessionProvider(_services)) {
                await _remoteBroker.ConnectAsync(sessionProvider);

                var session = sessionProvider.GetOrCreate(nameof(ConnectToRemote));
                await session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 5000);

                var evaluationResult = await session.EvaluateAsync <int>("1+2", REvaluationKind.Normal);

                evaluationResult.Should().Be(3);
            }
        }
예제 #9
0
        public async Task SwitchBrokerWithCancellation(int timeout)
        {
            using (var sessionProvider = new RSessionProvider(_coreServices)) {
                var session = sessionProvider.GetOrCreate(nameof(SwitchBrokerWithCancellation));
                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBrokerWithCancellation));

                await session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000);

                var result = await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBrokerWithCancellation) + "1",
                                                                        cancellationToken : new CancellationTokenSource(timeout).Token);

                result.Should().BeFalse();
            }
        }
예제 #10
0
        public async Task SwitchWhileEnsureHostStartedAsyncFailed()
        {
            using (var sessionProvider = new RSessionProvider(_services)) {
                var session = sessionProvider.GetOrCreate(nameof(SwitchWhileEnsureHostStartedAsyncFailed));
                session.RestartOnBrokerSwitch = true;

                var startTask = session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000);
                await Task.Yield();

                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchWhileEnsureHostStartedAsyncFailed));

                startTask.Should().BeCanceled();
                session.IsHostRunning.Should().BeTrue();
            }
        }
예제 #11
0
        public void GetOrCreate()
        {
            using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
                var guid     = new Guid();
                var session1 = sessionProvider.GetOrCreate(guid);
                session1.Should().NotBeNull();

                var session2 = sessionProvider.GetOrCreate(guid);
                session2.Should().BeSameAs(session1);

                session1.Dispose();
                var session3 = sessionProvider.GetOrCreate(guid);
                session3.Should().NotBeSameAs(session1);
                session3.Id.Should().NotBe(session1.Id);
            }
        }
예제 #12
0
        public async Task SwitchWhileEnsureHostStartedAsyncFailed()
        {
            using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
                var guid      = new Guid();
                var session   = sessionProvider.GetOrCreate(guid);
                var startTask = session.EnsureHostStartedAsync(new RHostStartupInfo {
                    Name = nameof(session)
                }, null, 1000);
                await Task.Yield();

                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchWhileEnsureHostStartedAsyncFailed));

                startTask.Should().BeCanceled();
                session.IsHostRunning.Should().BeTrue();
            }
        }
예제 #13
0
        public void GetOrCreate()
        {
            using (var sessionProvider = new RSessionProvider(_services)) {
                var guid     = Guid.NewGuid().ToString();
                var session1 = sessionProvider.GetOrCreate(guid);
                session1.Should().NotBeNull();

                var session2 = sessionProvider.GetOrCreate(guid);
                session2.Should().BeSameAs(session1);

                session1.Dispose();
                var session3 = sessionProvider.GetOrCreate(guid);
                session3.Should().NotBeSameAs(session1);
                session3.Id.Should().NotBe(session1.Id);
            }
        }
예제 #14
0
        private async Task ExecuteInSession(string[] inputs, IRSessionCallback app)
        {
            using (var sessionProvider = new RSessionProvider()) {
                var session = sessionProvider.GetOrCreate(Guid.NewGuid(), _brokerConnector);
                await session.StartHostAsync(new RHostStartupInfo {
                    Name = _testMethod.Name
                }, app, 50000);

                foreach (var input in inputs)
                {
                    using (var interaction = await session.BeginInteractionAsync()) {
                        await interaction.RespondAsync(input + "\n");
                    }
                }

                await session.StopHostAsync();
            }
        }
예제 #15
0
        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);
            }
        }
예제 #16
0
        public async Task SwitchBroker_DisposeSession(int timeout, bool restartOnBrokerSwitch)
        {
            using (var sessionProvider = new RSessionProvider(_services)) {
                var session = sessionProvider.GetOrCreate(nameof(SwitchBroker_DisposeSession));
                session.RestartOnBrokerSwitch = restartOnBrokerSwitch;

                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBroker_DisposeSession));

                await session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 5000);

                var sessionDisposeTask = Task.Delay(timeout).ContinueWith(t => session.Dispose());
                var result             = await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBroker_DisposeSession) + "1");

                await sessionDisposeTask;

                result.Should().BeTrue();
            }
        }
예제 #17
0
        public void GetOrCreate()
        {
            var sessionProvider = new RSessionProvider();
            var guid            = new Guid();
            var session1        = sessionProvider.GetOrCreate(guid, null);

            session1.Should().NotBeNull();

            var session2 = sessionProvider.GetOrCreate(guid, null);

            session2.Should().BeSameAs(session1);

            session1.Dispose();
            var session3 = sessionProvider.GetOrCreate(guid, null);

            session3.Should().NotBeSameAs(session1);
            session3.Id.Should().NotBe(session1.Id);
        }
예제 #18
0
        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();
            }
        }
예제 #19
0
        public async Task SwitchBrokerWithCancellation(int timeout)
        {
            using (var sessionProvider = new RSessionProvider(_services)) {
                var session = sessionProvider.GetOrCreate(nameof(SwitchBrokerWithCancellation));
                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBrokerWithCancellation));

                await session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000);

                var stopwatch = new Stopwatch();
                stopwatch.Start();
                var result = await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBrokerWithCancellation) + "1",
                                                                        cancellationToken : new CancellationTokenSource(timeout).Token);

                stopwatch.Stop();

                result.Should().Be(stopwatch.ElapsedMilliseconds < timeout);
            }
        }
예제 #20
0
        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);
            }
        }
예제 #21
0
        private async Task ExecuteInSession(string[] inputs, IRSessionCallback app)
        {
            using (var sessionProvider = new RSessionProvider(_services)) {
                await sessionProvider.TrySwitchBrokerAsync(nameof(IdeGraphicsDeviceTest));

                var session = sessionProvider.GetOrCreate(_testMethod.FileSystemSafeName);
                await session.StartHostAsync(new RHostStartupInfo(), app, 50000);

                foreach (var input in inputs)
                {
                    using (var interaction = await session.BeginInteractionAsync()) {
                        await interaction.RespondAsync(input.EnsureLineBreak());
                    }
                }

                await session.StopHostAsync();
            }
        }
예제 #22
0
        public async Task SwitchBroker_DisposeSessionProvider(int timeout)
        {
            var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal());
            var guid            = new Guid();
            var session         = sessionProvider.GetOrCreate(guid);
            await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBrokerWithCancellation));

            await session.EnsureHostStartedAsync(new RHostStartupInfo
            {
                Name = nameof(session)
            }, null, 5000);

            var sessionDisposeTask = Task.Delay(timeout).ContinueWith(t => sessionProvider.Dispose());
            var result             = await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchBrokerWithCancellation) + "1");

            await sessionDisposeTask;

            result.Should().BeFalse();
        }
예제 #23
0
        public async Task SwitchToTheSameBroker()
        {
            using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
                var guid    = new Guid();
                var session = sessionProvider.GetOrCreate(guid);
                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker));

                await session.EnsureHostStartedAsync(new RHostStartupInfo {
                    Name = nameof(session)
                }, null, 1000);

                var switch1Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker) + "1");
                var switch2Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToTheSameBroker) + "1");
                await Task.WhenAll(switch1Task, switch2Task);

                switch1Task.Status.Should().Be(TaskStatus.RanToCompletion);
                switch2Task.Status.Should().Be(TaskStatus.RanToCompletion);
            }
        }
예제 #24
0
        public async Task SwitchMultipleSessions()
        {
            using (var sessionProvider = new RSessionProvider(_services)) {
                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchMultipleSessions)).Should().BeCompletedAsync();

                var sessions = new IRSession[4];
                for (var i = 0; i < sessions.Length; i++)
                {
                    sessions[i] = sessionProvider.GetOrCreate(nameof(SwitchMultipleSessions) + i);
                    sessions[i].RestartOnBrokerSwitch = true;
                }

                await ParallelTools.WhenAll(30000, sessions.Select((s, i) => s.EnsureHostStartedAsync(new RHostStartupInfo(), null, 30000)).ToArray());

                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchMultipleSessions) + "1").Should().BeCompletedAsync();

                sessions.Should().OnlyContain(s => s.IsHostRunning);
            }
        }
예제 #25
0
        public RInteractiveWorkflow(IConnectionManagerProvider connectionsProvider
                                    , IRHistoryProvider historyProvider
                                    , IRPackageManagerProvider packagesProvider
                                    , IRPlotManagerProvider plotsProvider
                                    , IActiveWpfTextViewTracker activeTextViewTracker
                                    , IDebuggerModeTracker debuggerModeTracker
                                    , ICoreShell coreShell
                                    , IRSettings settings)
        {
            _activeTextViewTracker = activeTextViewTracker;
            _debuggerModeTracker   = debuggerModeTracker;
            _settings = settings;

            Shell     = coreShell;
            Console   = new InteractiveWindowConsole(this);
            RSessions = new RSessionProvider(coreShell.Services, Console);

            RSession    = RSessions.GetOrCreate(SessionNames.InteractiveWindow);
            Connections = connectionsProvider.CreateConnectionManager(this);

            History     = historyProvider.CreateRHistory(this);
            Packages    = packagesProvider.CreateRPackageManager(settings, this);
            Plots       = plotsProvider.CreatePlotManager(settings, this, new FileSystem());
            _operations = new RInteractiveWorkflowOperations(this, _debuggerModeTracker, Shell);

            _activeTextViewTracker.LastActiveTextViewChanged += LastActiveTextViewChanged;
            RSession.Disconnected += RSessionDisconnected;

            _debuggerModeTracker.EnterBreakMode += DebuggerEnteredBreakMode;
            _debuggerModeTracker.LeaveBreakMode += DebuggerLeftBreakMode;

            _settings.PropertyChanged += OnSettingsChanged;

            _disposableBag = DisposableBag.Create <RInteractiveWorkflow>()
                             .Add(() => _settings.PropertyChanged           -= OnSettingsChanged)
                             .Add(() => _debuggerModeTracker.EnterBreakMode -= DebuggerEnteredBreakMode)
                             .Add(() => _debuggerModeTracker.LeaveBreakMode -= DebuggerLeftBreakMode)
                             .Add(() => _activeTextViewTracker.LastActiveTextViewChanged -= LastActiveTextViewChanged)
                             .Add(() => RSession.Disconnected -= RSessionDisconnected)
                             .Add(RSessions)
                             .Add(Operations)
                             .Add(Connections);
        }
예제 #26
0
        public async Task SwitchToInvalid()
        {
            using (var sessionProvider = new RSessionProvider(_coreServices)) {
                var session = sessionProvider.GetOrCreate(nameof(SwitchToInvalid));
                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToInvalid));

                await session.EnsureHostStartedAsync(new RHostStartupInfo(), null, 1000);

                var switch1Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToInvalid) + "1", BrokerConnectionInfo.Create("JHFFR", @"\\JHF\F\R"));
                await Task.Yield();

                var switch2Task = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchToInvalid) + "2");
                await ParallelTools.WhenAll(30000, switch1Task, switch2Task);

                switch1Task.Should().BeRanToCompletion();
                switch1Task.Result.Should().BeFalse();
                switch2Task.Should().BeRanToCompletion();
                switch2Task.Result.Should().BeTrue();
            }
        }
예제 #27
0
        public async Task SwitchMultipleSessions()
        {
            using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchMultipleSessions));

                var sessions = new IRSession[4];
                for (var i = 0; i < sessions.Length; i++)
                {
                    sessions[i] = sessionProvider.GetOrCreate(new Guid());
                }

                await Task.WhenAll(sessions.Select((s, i) => s.EnsureHostStartedAsync(new RHostStartupInfo {
                    Name = nameof(sessions) + i
                }, null, 30000)));

                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(SwitchMultipleSessions) + "1");

                sessions.Should().OnlyContain(s => s.IsHostRunning);
            }
        }
예제 #28
0
        public async Task RemoveBroker()
        {
            var sessionProvider = new RSessionProvider(_services);
            var session1        = sessionProvider.GetOrCreate(nameof(RemoveBroker) + 1);
            var session2        = sessionProvider.GetOrCreate(nameof(RemoveBroker) + 2);

            session2.RestartOnBrokerSwitch = true;

            await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(RemoveBroker)).Should().BeCompletedAsync();

            session1.HostStarted.Should().NotBeCompleted();
            session2.HostStarted.Should().BeCompleted();

            await session1.EnsureHostStartedAsync(new RHostStartupInfo(), null, 5000).Should().BeCompletedAsync();

            await sessionProvider.RemoveBrokerAsync();

            session1.IsHostRunning.Should().BeFalse();
            session2.IsHostRunning.Should().BeFalse();
        }
예제 #29
0
        public async Task ConnectWhenSwitching_SwitchFailed()
        {
            using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
                await sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(ConnectWhenSwitching_SwitchFailed));

                var switchTask = sessionProvider.TrySwitchBrokerAsync(nameof(RSessionProviderTest) + nameof(ConnectWhenSwitching_SwitchFailed) + "1", @"\\JHF\F\R");
                await Task.Yield();

                var session       = sessionProvider.GetOrCreate(new Guid());
                var startHostTask = session.EnsureHostStartedAsync(new RHostStartupInfo {
                    Name = nameof(session)
                }, null, 1000);

                await Task.WhenAll(switchTask, startHostTask);

                startHostTask.Should().BeRanToCompletion();
                switchTask.Should().BeRanToCompletion();
                switchTask.Result.Should().BeFalse();
            }
        }
예제 #30
0
        private async Task <IEnumerable <string> > ExportToPdfAsync(string[] inputs, string filePath, int width, int height)
        {
            var app = new RHostClientTestApp {
                PlotHandler = OnPlot, PlotDeviceCreateHandler = OnDeviceCreate, PlotDeviceDestroyHandler = OnDeviceDestroy
            };

            using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) {
                await sessionProvider.TrySwitchBrokerAsync(nameof(IdeGraphicsDeviceTest));

                var session = sessionProvider.GetOrCreate(Guid.NewGuid());
                await session.StartHostAsync(new RHostStartupInfo {
                    Name = _testMethod.Name
                }, app, 50000);

                foreach (var input in inputs)
                {
                    using (var interaction = await session.BeginInteractionAsync()) {
                        await interaction.RespondAsync(input.EnsureLineBreak());
                    }
                }

                string script = String.Format(@"
device_id <- rtvs:::graphics.ide.getactivedeviceid()
rtvs:::export_to_pdf(device_id, rtvs:::graphics.ide.getactiveplotid(device_id), {0}, {1})
", width, height);
                var    blobid = await session.EvaluateAsync <ulong>(script, REvaluationKind.Normal);

                using (DataTransferSession dts = new DataTransferSession(session, new FileSystem())) {
                    await dts.FetchFileAsync(new RBlobInfo(blobid), filePath);
                }

                await session.StopHostAsync();
            }
            // Ensure that all plot files created by the graphics device have been deleted
            foreach (var plot in OriginalPlotMessages)
            {
                File.Exists(plot.FilePath).Should().BeFalse();
            }

            return(PlotFilePaths.AsReadOnly());
        }