public void ForkJoin_NaryParamsEmptyBeforeEnd()
        {
            var scheduler = new TestScheduler();

            var msgs1 = new[] {
                OnNext(150, 1),
                OnNext(215, 2),
                OnNext(225, 4),
                OnCompleted <int>(230)
            };

            var msgs2 = new[] {
                OnCompleted <int>(235)
            };

            var msgs3 = new[] {
                OnNext(150, 1),
                OnNext(230, 3),
                OnNext(245, 5),
                OnCompleted <int>(270)
            };

            var o1 = scheduler.CreateHotObservable(msgs1);
            var o2 = scheduler.CreateHotObservable(msgs2);
            var o3 = scheduler.CreateHotObservable(msgs3);

            var res = scheduler.Start(() => ObservableEx.ForkJoin(o1, o2, o3));

            res.Messages.AssertEqual(
                OnCompleted <int[]>(235)
                );
        }
        public void ForkJoin_None()
        {
            var scheduler = new TestScheduler();

            var res = scheduler.Start(() => ObservableEx.ForkJoin <int>());

            res.Messages.AssertEqual(
                OnCompleted <int[]>(200)
                );
        }
        public void ForkJoin_ArgumentChecking()
        {
            var someObservable = DummyObservable <int> .Instance;

            ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin(someObservable, someObservable, (Func <int, int, int>)null));
            ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin(someObservable, (IObservable <int>)null, (_, __) => _ + __));
            ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin((IObservable <int>)null, someObservable, (_, __) => _ + __));
            ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin((IObservable <int>[])null));
            ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin((IEnumerable <IObservable <int> >)null));
        }
Exemple #4
0
        protected virtual async Task <(ILanguageClient client, ILanguageServer server)> Initialize(
            Action <LanguageClientOptions> clientOptionsAction,
            Action <LanguageServerOptions> serverOptionsAction)
        {
            var clientPipe = new Pipe(TestOptions.DefaultPipeOptions);
            var serverPipe = new Pipe(TestOptions.DefaultPipeOptions);

            _client = LanguageClient.PreInit(options => {
                options
                .WithLoggerFactory(TestOptions.ClientLoggerFactory)
                .ConfigureLogging(x => {
                    x.Services.RemoveAll(typeof(ILoggerFactory));
                    x.Services.AddSingleton(TestOptions.ClientLoggerFactory);
                })
                .Services
                .AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>))
                .AddSingleton(ServerEvents as IRequestSettler);
                ConfigureClientInputOutput(serverPipe.Reader, clientPipe.Writer, options);
                clientOptionsAction(options);
            });

            _server = RealLanguageServer.PreInit(options => {
                options
                .WithLoggerFactory(TestOptions.ServerLoggerFactory)
                .ConfigureLogging(x => {
                    x.Services.RemoveAll(typeof(ILoggerFactory));
                    x.Services.AddSingleton(TestOptions.ServerLoggerFactory);
                })
                .Services
                .AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>))
                .AddSingleton(ServerEvents as IRequestSettler);
                ConfigureServerInputOutput(clientPipe.Reader, serverPipe.Writer, options);
                serverOptionsAction(options);
            });

            Disposable.Add(_client);
            Disposable.Add(_server);

            return(await ObservableEx.ForkJoin(
                       Observable.FromAsync(_client.Initialize),
                       Observable.FromAsync(_server.Initialize),
                       (a, b) => (_client, _server)
                       ).ToTask(CancellationToken));
        }
        public void ForkJoin_Nary()
        {
            var scheduler = new TestScheduler();

            var msgs1 = new[] {
                OnNext(150, 1),
                OnNext(215, 2),
                OnNext(225, 4),
                OnCompleted <int>(230)
            };

            var msgs2 = new[] {
                OnNext(150, 1),
                OnNext(235, 6),
                OnNext(240, 7),
                OnCompleted <int>(250)
            };

            var msgs3 = new[] {
                OnNext(150, 1),
                OnNext(230, 3),
                OnNext(245, 5),
                OnCompleted <int>(270)
            };

            var o1 = scheduler.CreateHotObservable(msgs1);
            var o2 = scheduler.CreateHotObservable(msgs2);
            var o3 = scheduler.CreateHotObservable(msgs3);

            var res = scheduler.Start(() => ObservableEx.ForkJoin(new List <IObservable <int> > {
                o1, o2, o3
            }));

            res.Messages.AssertEqual(
                OnNext <int[]>(270, l => l.SequenceEqual(new[] { 4, 7, 5 })), // TODO: fix ForkJoin behavior
                OnCompleted <int[]>(270)
                );
        }
 public void ForkJoin_Nary_Immediate()
 {
     ObservableEx.ForkJoin(Observable.Return(1), Observable.Return(2)).First().SequenceEqual(new[] { 1, 2 });
 }