Esempio n. 1
0
        public async Task Test_Publish()
        {
            var connectableObservable = AutoObservable.Create <string>(int.MaxValue, TimeSpan.FromMilliseconds(10))
                                        .Publish();
            await Assert.ThrowsAsync <TimeoutException>(async() => await connectableObservable.FirstAsync().Timeout(TimeSpan.FromMilliseconds(50)));

            var mre = new ManualResetEventSlim();

            connectableObservable.Subscribe(x => mre.Set());
            await Assert.ThrowsAsync <TimeoutException>(async() => await connectableObservable.FirstAsync().Timeout(TimeSpan.FromMilliseconds(50)));

            Assert.False(mre.IsSet);

            var connection = connectableObservable.Connect();
            await connectableObservable.FirstAsync();

            Assert.True(mre.IsSet);

            connection.Dispose();
            mre.Reset();
            connectableObservable.Connect();
            await connectableObservable.FirstAsync();

            Assert.True(mre.IsSet); // Connected().Dispose() does not dispose subscriptions!
            await Task.Delay(100);
        }
Esempio n. 2
0
        public async Task Test_Concurrent()
        {
            const int count  = 11;
            const int taskNo = 7;

            var observable = AutoObservable.Create <string>(count, TimeSpan.FromMilliseconds(1));
            var tasks      = new List <Task <IList <string> > >();

            for (var i = 0; i < taskNo; i++)
            {
                tasks.Add(observable.ToList().ToTask());
                await Task.Delay(2);
            }
            var allOk = true;

            foreach (var task in tasks)
            {
                var list = await task;
                if (list.Count != count)
                {
                    allOk = false;
                    Write("FAILURE " + list.Count);
                }
            }
            Assert.True(allOk);
        }
Esempio n. 3
0
        public async Task Test_Single()
        {
            var observable1 = Observable.Return("x");
            await observable1.SingleAsync();

            var observable = AutoObservable.Create <string>(count: 1);
            await observable.SingleAsync();
        }
Esempio n. 4
0
        public async Task Test_Timeout()
        {
            var observable1 = Observable.Never <string>();
            await Assert.ThrowsAsync <TimeoutException>(async() => await observable1.Timeout(TimeSpan.FromMilliseconds(1)));

            var observable2 = AutoObservable.Create <string>(count: int.MaxValue, delay: TimeSpan.FromMilliseconds(100));
            await Assert.ThrowsAsync <TimeoutException>(async() => await observable2.Timeout(TimeSpan.FromMilliseconds(1)));
        }
Esempio n. 5
0
        public async Task Test_Empty()
        {
            var observable1 = Observable.Empty <string>();
            var ex1         = await Assert.ThrowsAsync <InvalidOperationException>(async() => await observable1);

            var observable2 = AutoObservable.Create <string>(count: 0);
            var ex2         = await Assert.ThrowsAsync <InvalidOperationException>(async() => await observable2);

            Write(ex1.Message);
            Assert.Equal(ex1.Message, ex2.Message);
        }
Esempio n. 6
0
        public async Task Test_Many()
        {
            const int count = 11;

            var observables1 = Observable.Range(1, count);
            var list1        = await observables1.ToList();

            Assert.Equal(count, list1.Count);

            var observable = AutoObservable.Create <string>(count);
            var list       = await observable.ToList();

            Assert.Equal(count, list.Count);
        }
Esempio n. 7
0
        public async Task Test_Unsubscribe_Publish()
        {
            var connectableObservable = AutoObservable.Create <string>(int.MaxValue, TimeSpan.FromMilliseconds(10)).Publish();
            var connection            = connectableObservable.Connect();

            var subscription = connectableObservable.Subscribe(
                onNext: message => Write("OnNext: " + message.Stringify()),
                onError: ex => Write("OnError: " + ex.Message),
                onCompleted: () => Write("OnCompleted!"));

            await Task.Delay(100);

            //subscription.Dispose();

            connection.Dispose(); // OnCompleted is not called

            await Task.Delay(100);
        }