public void Dispose() { var cs1 = new MaybeSubject <int>(); var cs2 = new MaybeSubject <int>(); var to = cs1 .TakeUntil(cs2) .Test(); Assert.True(cs1.HasObserver()); Assert.True(cs2.HasObserver()); to.Dispose(); Assert.False(cs1.HasObserver()); Assert.False(cs2.HasObserver()); to.AssertEmpty(); }
public void Observable_Basic_Other() { var cs1 = new MaybeSubject <int>(); var cs2 = new UnicastSubject <int>(); var to = cs1 .TakeUntil(cs2) .Test(); Assert.True(cs1.HasObserver()); Assert.True(cs2.HasObserver()); cs2.OnCompleted(); Assert.False(cs1.HasObserver()); Assert.False(cs2.HasObserver()); to.AssertResult(); }
public void Observable_Error_Other() { var cs1 = new MaybeSubject <int>(); var cs2 = new UnicastSubject <int>(); var to = cs1 .TakeUntil(cs2) .Test(); Assert.True(cs1.HasObserver()); Assert.True(cs2.HasObserver()); cs2.OnError(new InvalidOperationException()); Assert.False(cs1.HasObserver()); Assert.False(cs2.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); }
public void Observable_Success() { var cs1 = new MaybeSubject <int>(); var cs2 = new UnicastSubject <int>(); var to = cs1 .TakeUntil(cs2) .Test(); Assert.True(cs1.HasObserver()); Assert.True(cs2.HasObserver()); cs1.OnSuccess(1); Assert.False(cs1.HasObserver()); Assert.False(cs2.HasObserver()); to.AssertResult(1); }
public void Limited_Eager_Empty_First() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new[] { ms1, ms2 }.ToObservable() .FlatMap(v => v, maxConcurrency: 1) .Test(); Assert.True(ms1.HasObserver()); Assert.False(ms2.HasObserver()); ms1.OnCompleted(); Assert.True(ms2.HasObserver()); ms2.OnSuccess(2); to.AssertResult(2); }
public void Max_Delayed_Dispose() { var subj = new Subject <int>(); var ms = new MaybeSubject <int>(); var to = subj.FlatMap(v => ms, true).Test(); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnNext(1); Assert.True(subj.HasObservers); Assert.True(ms.HasObserver()); to.Dispose(); Assert.False(subj.HasObservers); Assert.False(ms.HasObserver()); }
public void Limited_Delayed_Error_First() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new[] { ms1, ms2 }.ToObservable() .FlatMap(v => v, true, maxConcurrency: 1) .Test(); Assert.True(ms1.HasObserver()); Assert.False(ms2.HasObserver()); ms1.OnError(new InvalidOperationException()); Assert.True(ms2.HasObserver()); ms2.OnSuccess(2); to.AssertFailure(typeof(InvalidOperationException), 2); }
public void Dispose() { var subj = new Subject <int>(); var ms = new MaybeSubject <int>(); var to = subj.ConcatMap(v => ms).Test(); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnNext(1); Assert.True(subj.HasObservers); Assert.True(ms.HasObserver()); to.Dispose(); Assert.False(subj.HasObservers); Assert.False(ms.HasObserver()); }
public void Limited_Delayed_Success_First() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new[] { ms1, ms2 }.ToObservable() .FlatMap(v => v, true, maxConcurrency: 1) .Test(); Assert.True(ms1.HasObserver()); Assert.False(ms2.HasObserver()); ms1.OnSuccess(1); Assert.True(ms2.HasObserver()); ms2.OnSuccess(2); to.AssertResult(1, 2); }
public void Enumerable_Max_Dispose() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = MaybeSource.ConcatEager( new List <IMaybeSource <int> >() { ms1, ms2 }) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); to.Dispose(); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); }
public void Array_Limit_Keep_Order() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = MaybeSource.ConcatEager(2, ms1, ms2 ) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); ms2.OnSuccess(2); to.AssertEmpty(); ms1.OnSuccess(1); to.AssertResult(1, 2); }
public void Enumerable_Limited_Dispose() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new List <IMaybeSource <int> >() { ms1, ms2 } .Merge(maxConcurrency: 2) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); to.Dispose(); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); }
public void Array_Limited_Dispose() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new[] { ms1, ms2 } .MergeAll(maxConcurrency: 2) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); to.Dispose(); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); }
public void Timeout() { var ts = new TestScheduler(); var us = new MaybeSubject <int>(); var to = us .Timeout(TimeSpan.FromSeconds(1), ts) .Test(); to.AssertEmpty(); ts.AdvanceTimeBy(100); Assert.True(us.HasObserver()); ts.AdvanceTimeBy(900); Assert.False(us.HasObserver()); to.AssertFailure(typeof(TimeoutException)); }
public void Max_Eager_Dispose_Inner_Error() { var subj = new Subject <int>(); var ms = new MaybeSubject <int>(); var to = subj.FlatMap(v => ms).Test(); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnNext(1); Assert.True(ms.HasObserver()); ms.OnError(new InvalidOperationException()); Assert.False(subj.HasObservers); Assert.False(ms.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); }
public void No_Timeout_Error() { var ts = new TestScheduler(); var us = new MaybeSubject <int>(); var to = us .Timeout(TimeSpan.FromSeconds(1), ts) .Test(); to.AssertEmpty(); ts.AdvanceTimeBy(100); Assert.True(us.HasObserver()); us.OnError(new InvalidOperationException()); ts.AdvanceTimeBy(900); to.AssertFailure(typeof(InvalidOperationException)); }
public void No_Timeout() { var ts = new TestScheduler(); var us = new MaybeSubject <int>(); var to = us .Timeout(TimeSpan.FromSeconds(1), ts) .Test(); to.AssertEmpty(); ts.AdvanceTimeBy(100); Assert.True(us.HasObserver()); us.OnCompleted(); ts.AdvanceTimeBy(900); to.AssertResult(); }
public void Array_Max_Dispose() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new[] { ms1, ms2 } .MergeAll() .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); to.Dispose(); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); }
public void Success() { var ms = new MaybeSubject <int>(); Assert.False(ms.HasObservers); Assert.False(ms.HasCompleted()); Assert.False(ms.HasException()); Assert.IsNull(ms.GetException()); Assert.False(ms.HasValue()); Assert.False(ms.TryGetValue(out var _)); var to = ms.Test(); Assert.True(ms.HasObservers); Assert.False(ms.HasCompleted()); Assert.False(ms.HasException()); Assert.IsNull(ms.GetException()); Assert.False(ms.HasValue()); Assert.False(ms.TryGetValue(out var _)); to.AssertSubscribed().AssertEmpty(); ms.OnSuccess(1); Assert.False(ms.HasObservers); Assert.False(ms.HasCompleted()); Assert.False(ms.HasException()); Assert.IsNull(ms.GetException()); Assert.True(ms.HasValue()); var v = default(int); Assert.True(ms.TryGetValue(out v)); Assert.AreEqual(1, v); to.AssertResult(1); ms.Test().AssertSubscribed().AssertResult(1); ms.Test(true).AssertSubscribed().AssertEmpty(); }
public void Other_Dispose_Other() { var ts = new MaybeSubject <int>(); var cs = new MaybeSubject <int>(); var to = cs .DelaySubscription(ts) .Test(); Assert.False(cs.HasObserver()); ts.OnCompleted(); Assert.True(cs.HasObserver()); to.Dispose(); Assert.False(cs.HasObserver()); to.AssertEmpty(); }
public void Max_Error_Dispose_Second() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = MaybeSource.ConcatEager( new [] { ms1, ms2 }.ToObservable() ) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); ms2.OnError(new InvalidOperationException()); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); }
public void Max_Delayed_Main_Completes_Inner_Empty() { var subj = new Subject <int>(); var ms = new MaybeSubject <int>(); var to = subj.FlatMap(v => ms, true).Test(); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnNext(1); subj.OnCompleted(); Assert.True(ms.HasObserver()); ms.OnCompleted(); Assert.False(subj.HasObservers); Assert.False(ms.HasObserver()); to.AssertResult(); }
public void Array_Limit_Max_Concurrency() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = MaybeSource.ConcatEager(1, ms1, ms2 ) .Test(); Assert.True(ms1.HasObserver()); Assert.False(ms2.HasObserver()); ms1.OnSuccess(1); Assert.False(ms1.HasObserver()); Assert.True(ms2.HasObserver()); ms2.OnSuccess(2); to.AssertResult(1, 2); }
public void Max_Eager_Main_Completes_Inner_Succeeds() { var subj = new Subject <int>(); var ms = new MaybeSubject <int>(); var to = subj.FlatMap(v => ms).Test(); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnNext(1); subj.OnCompleted(); Assert.True(ms.HasObserver()); ms.OnSuccess(1); Assert.False(subj.HasObservers); Assert.False(ms.HasObserver()); to.AssertResult(1); }
public void Error() { var ms = new MaybeSubject <int>(); Assert.False(ms.HasObserver()); Assert.False(ms.HasCompleted()); Assert.False(ms.HasException()); Assert.IsNull(ms.GetException()); Assert.False(ms.HasValue()); Assert.False(ms.TryGetValue(out var _)); var to = ms.Test(); Assert.True(ms.HasObserver()); Assert.False(ms.HasCompleted()); Assert.False(ms.HasException()); Assert.IsNull(ms.GetException()); Assert.False(ms.HasValue()); Assert.False(ms.TryGetValue(out var _)); to.AssertSubscribed().AssertEmpty(); ms.OnError(new InvalidOperationException()); Assert.False(ms.HasObserver()); Assert.False(ms.HasCompleted()); Assert.True(ms.HasException()); Assert.IsNotNull(ms.GetException()); Assert.True(typeof(InvalidOperationException).IsAssignableFrom(ms.GetException().GetType())); Assert.False(ms.HasValue()); Assert.False(ms.TryGetValue(out var _)); to.AssertFailure(typeof(InvalidOperationException)); ms.Test().AssertSubscribed().AssertFailure(typeof(InvalidOperationException)); ms.Test(true).AssertSubscribed().AssertEmpty(); }
public void Enumerable_Limited_Dispose_On_Error() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new List <IMaybeSource <int> >() { ms1, ms2 } .Merge(maxConcurrency: 2) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); ms2.OnError(new InvalidOperationException()); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); }
public void Dispose_Fallback() { var ts = new TestScheduler(); var us = new MaybeSubject <int>(); var to = MaybeSource.Never <int>() .Timeout(TimeSpan.FromSeconds(1), ts, us) .Test(); ts.AdvanceTimeBy(100); Assert.False(us.HasObserver()); ts.AdvanceTimeBy(900); Assert.True(us.HasObserver()); to.Dispose(); Assert.False(us.HasObserver()); to.AssertEmpty(); }
public void Enumerable_Max_Error_Dispose_First() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = MaybeSource.ConcatEager( new List <IMaybeSource <int> >() { ms1, ms2 } ) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); ms1.OnError(new InvalidOperationException()); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); }
public void Array_Max_Dispose_On_Error() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = new[] { ms1, ms2 } .MergeAll() .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); ms2.OnError(new InvalidOperationException()); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); }
public void Limit_Keep_Order() { var ms1 = new MaybeSubject <int>(); var ms2 = new MaybeSubject <int>(); var to = MaybeSource.ConcatEager( new [] { ms1, ms2 }.ToObservable(), maxConcurrency: 2 ) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); ms2.OnSuccess(2); to.AssertEmpty(); ms1.OnSuccess(1); to.AssertResult(1, 2); }