public void Timeout_Fallback_Error() { var ts = new TestScheduler(); var us = new SingleSubject <int>(); var count = 0; var fb = SingleSource.FromFunc <int>(() => { ++count; throw new InvalidOperationException(); }); var to = us .Timeout(TimeSpan.FromSeconds(1), ts, fb) .Test(); to.AssertEmpty(); ts.AdvanceTimeBy(100); Assert.True(us.HasObserver()); ts.AdvanceTimeBy(900); Assert.False(us.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(1, count); }
public void Limit_Error_Stop() { for (int i = 1; i < 10; i++) { var count = 0; var src = SingleSource.FromFunc(() => ++ count); var to = new [] { SingleSource.Just(1), SingleSource.Error <int>(new InvalidOperationException()), src }.ToObservable() .ConcatEager(maxConcurrency: i) .Test(); to .AssertNotCompleted() .AssertError(typeof(InvalidOperationException)); Assert.AreEqual(0, count); } }
public void Timeout_Fallback_Success() { var ts = new TestScheduler(); var us = new SingleSubject <int>(); var count = 0; var fb = SingleSource.FromFunc <int>(() => ++ count); var to = us .Timeout(TimeSpan.FromSeconds(1), ts, fb) .Test(); to.AssertEmpty(); ts.AdvanceTimeBy(100); Assert.True(us.HasObserver()); ts.AdvanceTimeBy(900); Assert.False(us.HasObserver()); to.AssertResult(1); Assert.AreEqual(1, count); }
public void Enumerable_Limit_Error_Stop() { for (int i = 1; i < 10; i++) { var count = 0; var src = SingleSource.FromFunc(() => ++ count); var to = new List <ISingleSource <int> >() { SingleSource.Just(1), SingleSource.Error <int>(new InvalidOperationException()), src } .ConcatEager(maxConcurrency: i) .Test(); if (i >= 2) { to.AssertFailure(typeof(InvalidOperationException)); } else { to.AssertFailure(typeof(InvalidOperationException), 1); } Assert.AreEqual(0, count); } }
public void Action_Just_Ignored() { var count = 0; SingleSource.FromFunc(() => ++ count) .BlockingSubscribe(); Assert.AreEqual(1, count); }
public void Dispose_Upfront() { var count = 0; SingleSource.FromFunc(() => ++ count) .Test(true) .AssertEmpty(); Assert.AreEqual(0, count); }
public void Basic() { var count = 0; SingleSource.FromFunc(() => ++ count) .RetryWhen(v => v) .Test() .AssertResult(1); Assert.AreEqual(1, count); }
public void Error_Fallback_Success() { var count = 0; var fb = SingleSource.FromFunc(() => ++ count); SingleSource.Error <int>(new InvalidOperationException()) .OnErrorResumeNext(fb) .Test() .AssertResult(1); Assert.AreEqual(1, count); }
public void Handler_Success() { var count = 0; var fb = SingleSource.FromFunc <int>(() => count++); SingleSource.Just(1) .OnErrorResumeNext(e => fb) .Test() .AssertResult(1); Assert.AreEqual(0, count); }
public void Handler_Error() { var count = 0; var fb = SingleSource.FromFunc <int>(() => count++); SingleSource.Error <int>(new InvalidOperationException()) .OnErrorResumeNext(e => fb) .Test() .AssertResult(0); Assert.AreEqual(1, count); }
public void Success_Fallback() { var count = 0; var fb = SingleSource.FromFunc <int>(() => count++); SingleSource.Just(1) .Timeout(TimeSpan.FromMinutes(1), NewThreadScheduler.Default, fb) .Test() .AssertResult(1); Assert.AreEqual(0, count); }
public void Error_Fallback() { var count = 0; var fb = SingleSource.FromFunc <int>(() => count++); SingleSource.Error <int>(new InvalidOperationException()) .Timeout(TimeSpan.FromMinutes(1), NewThreadScheduler.Default, fb) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(0, count); }
public void Dispose_During_Error() { var to = new TestObserver <int>(); SingleSource.FromFunc <int>(() => { to.Dispose(); throw new InvalidOperationException(); }) .SubscribeWith(to) .AssertEmpty(); Assert.True(to.IsDisposed()); }
public void Dispose_During() { var to = new TestObserver <int>(); SingleSource.FromFunc(() => { to.Dispose(); return(1); }) .SubscribeWith(to) .AssertEmpty(); Assert.True(to.IsDisposed()); }
public void Single_Error() { var count = 0; MaybeSource.Error <int>(new InvalidOperationException()) .FlatMap(v => SingleSource.FromFunc <string>(() => { return("" + (++count)); })) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(0, count); }
public void Handler_False() { var count = 0; var src = SingleSource.FromFunc(() => ++ count); var obs = src.Repeat(v => false); obs .Test() .AssertResult(1); Assert.AreEqual(1, count); }
public void Handler_Limit() { var count = 0; var src = SingleSource.FromFunc(() => ++ count); var obs = src.Repeat(v => v < 5); obs .Test() .AssertResult(1, 2, 3, 4, 5); Assert.AreEqual(5, count); }
public void Single_Empty() { var count = 0; MaybeSource.Empty <int>() .FlatMap(v => SingleSource.FromFunc(() => { count++; return(v + 1); })) .Test() .AssertResult(); Assert.AreEqual(0, count); }
public void Basic() { var count = 0; SingleSource.FromFunc(() => ++ count) .RepeatWhen(v => v) .SubscribeOn(NewThreadScheduler.Default) .Take(5) .Test() .AwaitDone(TimeSpan.FromSeconds(5)) .AssertResult(1, 2, 3, 4, 5); Assert.True(count >= 5, $"{count}"); }
public void Array_First_Wins_Error() { var count = 0; var m = SingleSource.FromFunc <int>(() => ++ count); SingleSource.Amb( SingleSource.Error <int>(new InvalidOperationException()), m ) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(0, count); }
public void Error() { var count = 0; SingleSource.FromFunc <int>(() => { count++; throw new InvalidOperationException(); }) .RepeatWhen(v => v) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(1, count); }
public void DisposeUpfront() { var name = -1; SingleSource.FromFunc <int>(() => { name = Thread.CurrentThread.ManagedThreadId; throw new InvalidOperationException(); }) .SubscribeOn(NewThreadScheduler.Default) .Test(true) .AssertEmpty(); Assert.AreEqual(-1, name); }
public void Limited_Repeat() { var count = 0; SingleSource.FromFunc(() => ++ count) .RepeatWhen(v => { var idx = 0; return(v.TakeWhile(w => ++ idx < 5)); }) .Test() .AssertResult(1, 2, 3, 4, 5); Assert.AreEqual(5, count); }
public void Handler_Error() { var count = 0; SingleSource.FromFunc <int>(() => { if (++count < 5) { throw new InvalidOperationException(); } return(count); }) .Retry((e, i) => true) .Test() .AssertResult(5); }
public void Times_Error_Limit_Fail() { var count = 0; SingleSource.FromFunc <int>(() => { if (++count < 5) { throw new InvalidOperationException(); } return(count); }) .Retry(3) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Times_Error_Limit() { var count = 0; SingleSource.FromFunc <int>(() => { if (++count < 5) { throw new InvalidOperationException(); } return(count); }) .Retry(5) .Test() .AssertResult(5); }
public void Array_Max_Error_Delay() { var count = 0; var src = SingleSource.FromFunc(() => ++ count); SingleSource.ConcatEager(true, SingleSource.Just(0), SingleSource.Error <int>(new InvalidOperationException()), src ) .Test() .AssertFailure(typeof(InvalidOperationException), 0, 1); Assert.AreEqual(1, count); }
public void Array_Second_Wins_Success() { var count = 0; var m = SingleSource.FromFunc <int>(() => ++ count); new[] { SingleSource.Never <int>(), m } .AmbAll() .Test() .AssertResult(1); Assert.AreEqual(1, count); }
public void Array_First_Wins_Success() { var count = 0; var m = SingleSource.FromFunc <int>(() => ++ count); new[] { SingleSource.Just(0), m } .AmbAll() .Test() .AssertResult(0); Assert.AreEqual(0, count); }
public void Enumerable_Second_Wins_Success() { var count = 0; var m = SingleSource.FromFunc <int>(() => ++ count); new List <ISingleSource <int> >() { SingleSource.Never <int>(), m } .Amb() .Test() .AssertResult(1); Assert.AreEqual(1, count); }