public void Times_Error() { SingleSource.Error <int>(new InvalidOperationException()) .Repeat() .Test() .AssertFailure(typeof(InvalidOperationException)); }
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 Error() { SingleSource.Error <int>(new InvalidOperationException()) .OnTerminateDetach() .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void All_Error() { var success = 0; var afterSuccess = 0; var error = 0; var terminate = 0; var afterterminate = 0; var subscribe = 0; var dispose = 0; var final = 0; SingleSource.Error <int>(new InvalidOperationException()) .DoOnSuccess(v => success++) .DoOnSuccess(v => afterSuccess++) .DoOnError(e => error++) .DoOnTerminate(() => terminate++) .DoAfterTerminate(() => afterterminate++) .DoOnSubscribe(d => subscribe++) .DoOnDispose(() => dispose++) .DoFinally(() => final++) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(0, success); Assert.AreEqual(0, afterSuccess); Assert.AreEqual(1, error); Assert.AreEqual(1, terminate); Assert.AreEqual(1, afterterminate); Assert.AreEqual(1, subscribe); Assert.AreEqual(0, dispose); Assert.AreEqual(1, final); }
public void Error() { SingleSource.Error <int>(new InvalidOperationException()) .Timeout(TimeSpan.FromMinutes(1), NewThreadScheduler.Default) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Single_Error_Inner() { SingleSource.Just(1) .FlatMap(v => SingleSource.Error <int>(new InvalidOperationException())) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Dispose_Fallback() { TestHelper.VerifyDisposeSingle <int, int>(m => SingleSource.Error <int>(new InvalidOperationException()) .OnErrorResumeNext(m) ); }
public void Error() { IMaybeSource <int> src = SingleSource.Error <int>(new InvalidOperationException()) .ToMaybe(); src.Test().AssertFailure(typeof(InvalidOperationException)); }
public void Single_Next_Error() { CompletableSource.Empty() .AndThen(SingleSource.Error <int>(new InvalidOperationException())) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Error() { SingleSource.Error <int>(new InvalidOperationException()) .Filter(v => true) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Single_Error() { SingleSource.Error <int>(new InvalidOperationException()) .IgnoreElement() .Test() .AssertFailure(typeof(InvalidOperationException)); }
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 Error() { SingleSource.Error <int>(new InvalidOperationException()) .Map(v => "" + (v + 1)) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Single_Error_Fallback() { MaybeSource.Empty <int>() .SwitchIfEmpty(SingleSource.Error <int>(new InvalidOperationException())) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Error() { // do not make this var to ensure the target type is correct IObservable <int> o = SingleSource.Error <int>(new InvalidOperationException()).ToObservable <int>(); o.Test().AssertFailure(typeof(InvalidOperationException)); }
public void MoveNext_Crash() { SingleSource.Error <int>(new InvalidOperationException()) .FlatMap(v => new FailingEnumerable <int>(false, true, false)) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Error() { SingleSource.Error <int>(new InvalidOperationException()) .FlatMap(v => Enumerable.Range(v, 5)) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Basic() { SingleSource.Error <int>(new InvalidOperationException()) .Test() .AssertSubscribed() .AssertFailure(typeof(InvalidOperationException)); }
public void Fallback_Error() { SingleSource.Error <int>(new InvalidOperationException("main")) .OnErrorResumeNext(SingleSource.Error <int>(new InvalidOperationException("fallback"))) .Test() .AssertFailure(typeof(InvalidOperationException)) .AssertError(typeof(InvalidOperationException), "fallback"); }
public void Time_Error() { SingleSource.Error <int>(new InvalidOperationException()) .DelaySubscription(TimeSpan.FromMilliseconds(100), NewThreadScheduler.Default) .Test() .AwaitDone(TimeSpan.FromSeconds(5)) .AssertFailure(typeof(InvalidOperationException)); }
public void Other_Delay_Error() { SingleSource.Error <int>(new NullReferenceException()) .DelaySubscription(SingleSource.Error <int>(new InvalidOperationException())) .Test() .AwaitDone(TimeSpan.FromSeconds(5)) .AssertFailure(typeof(InvalidOperationException)); }
public IDisposable Subscribe(IObserver <T> observer) { var en = default(IEnumerator <ISingleSource <T> >); try { en = RequireNonNullRef(sources.GetEnumerator(), "The GetEnumerator returned a null IEnumerator"); } catch (Exception ex) { observer.OnError(ex); return(DisposableHelper.EMPTY); } if (maxConcurrency == int.MaxValue) { var parent = new SingleConcatEagerAllCoordinator <T>(observer, delayErrors); for (; ;) { var b = false; var src = default(ISingleSource <T>); try { b = en.MoveNext(); if (!b) { break; } src = en.Current; } catch (Exception ex) { parent.SubscribeTo(SingleSource.Error <T>(ex)); break; } if (!parent.SubscribeTo(src)) { break; } } en.Dispose(); parent.Done(); return(parent); } else { var parent = new ConcatEagerLimitedCoordinator(observer, en, maxConcurrency, delayErrors); parent.Drain(); return(parent); } }
public void Error() { var count = 0; SingleSource.Error <int>(new InvalidOperationException()) .Subscribe(v => { count = v; }, e => { count = 2; }); Assert.AreEqual(2, count); }
public void Array_Max_Error() { SingleSource.Merge( SingleSource.Error <int>(new InvalidOperationException()), SingleSource.Just(1) ) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Observer_Error() { var to = new TestObserver <int>(); SingleSource.Error <int>(new InvalidOperationException()) .BlockingSubscribe(to); to.AssertFailure(typeof(InvalidOperationException)); }
public void Normal_Error() { var to = new TestObserver <int>(); SingleSource.Error <int>(new InvalidOperationException()) .SubscribeSafe(to); to.AssertSubscribed() .AssertFailure(typeof(InvalidOperationException)); }
public void Array_Max_Error_Delayed() { SingleSource.Merge(true, SingleSource.Just(1), SingleSource.Error <int>(new InvalidOperationException()), SingleSource.Just(2) ) .Test() .AssertFailure(typeof(InvalidOperationException), 1, 2); }
public void Error_Cleanup_Crash_Non_Eager() { SingleSource.Using(() => 1, v => SingleSource.Error <int>(new NotImplementedException()), v => { throw new InvalidOperationException(); }, false ) .Test() .AssertFailure(typeof(NotImplementedException)); }
public void Handler_Crash() { SingleSource.Error <int>(new InvalidOperationException("main")) .OnErrorResumeNext(e => { throw new InvalidOperationException("fallback"); }) .Test() .AssertFailure(typeof(AggregateException)) .AssertCompositeErrorCount(2) .AssertCompositeError(0, typeof(InvalidOperationException), "main") .AssertCompositeError(1, typeof(InvalidOperationException), "fallback"); }
public void OnError_Basic() { var count = 0; SingleSource.Error <int>(new InvalidOperationException()) .DoOnError(e => count++) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(1, count); }