public void Enumerable_Limit_Max_Concurrency() { var ms1 = new SingleSubject <int>(); var ms2 = new SingleSubject <int>(); var to = SingleSource.ConcatEager( new List <ISingleSource <int> >() { ms1, ms2 } , maxConcurrency: 1 ) .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 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 Observer_Dispose() { for (int i = 0; i < TestHelper.RACE_LOOPS; i++) { var cs = new SingleSubject <int>(); var to = new TestObserver <int>(); var cdl = new CountdownEvent(1); Task.Factory.StartNew(() => { while (!cs.HasObserver()) { ; } to.Dispose(); cdl.Signal(); }); cs.BlockingSubscribe(to); cdl.Wait(); Assert.False(cs.HasObserver()); } }
public void Value_Cancel_Wait() { var cs = new SingleSubject <int>(); var cts = new CancellationTokenSource(); try { Task.Factory.StartNew(() => { while (!cs.HasObserver()) { ; } Thread.Sleep(100); cts.Cancel(); }); cs .Wait(cts: cts); Assert.Fail(); } catch (OperationCanceledException) { // expected } Assert.False(cs.HasObserver()); }
public void Time_Dispose_Other() { var ts = new TestScheduler(); var cs = new SingleSubject <int>(); var to = cs .DelaySubscription(TimeSpan.FromSeconds(1), ts) .Test(); Assert.False(cs.HasObserver()); ts.AdvanceTimeBy(500); Assert.False(cs.HasObserver()); ts.AdvanceTimeBy(500); Assert.True(cs.HasObserver()); to.Dispose(); Assert.False(cs.HasObserver()); to.AssertEmpty(); }
public void Limited_Delayed_Main_Completes_Inner_Succeeds() { for (int k = 1; k < 10; k++) { var subj = new Subject <int>(); var ms = new SingleSubject <int>(); var to = subj.FlatMap(v => ms, true, k).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 Single_Dispose_Inner() { var ss = new SingleSubject <int>(); var cs = new CompletableSubject(); var to = ss .FlatMap(v => cs) .Test(); to.AssertSubscribed(); Assert.True(ss.HasObserver()); Assert.False(cs.HasObserver()); ss.OnSuccess(1); Assert.True(cs.HasObserver()); Assert.False(ss.HasObserver()); to.AssertEmpty(); cs.OnCompleted(); to.AssertResult(); }
public void Limited_Delayed_Dispose_Inner_Error() { for (int k = 1; k < 10; k++) { var subj = new Subject <int>(); var ms = new SingleSubject <int>(); var to = subj.FlatMap(v => ms, true, k).Test(); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnNext(1); Assert.True(ms.HasObserver()); ms.OnError(new InvalidOperationException()); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnCompleted(); to.AssertFailure(typeof(InvalidOperationException)); } }
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 Inner_Error_Delayed() { var subj = new Subject <int>(); var ms = new SingleSubject <int>(); var to = subj.ConcatMap(v => ms, true).Test(); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); subj.OnNext(1); Assert.True(subj.HasObservers); Assert.True(ms.HasObserver()); ms.OnError(new InvalidOperationException()); Assert.True(subj.HasObservers); Assert.False(ms.HasObserver()); to.AssertEmpty(); subj.OnCompleted(); to.AssertFailure(typeof(InvalidOperationException)); }
public void Enumerable_Limited_Subscription() { var ms1 = new SingleSubject <int>(); var ms2 = new SingleSubject <int>(); var to = new List <ISingleSource <int> >() { ms1, ms2 } .Merge(maxConcurrency: 1) .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 Array_Limited_Subscription() { var ms1 = new SingleSubject <int>(); var ms2 = new SingleSubject <int>(); var to = new[] { ms1, ms2 } .MergeAll(maxConcurrency: 1) .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); }
/// <summary> /// Calls a transform function with an SingleSubject, /// subscribes to the resulting ISingleSource, disposes /// the connection and verifies if the SingleSubject /// lost its observer, verifying the Dispose() call /// composes through. /// </summary> /// <typeparam name="T">The source value type.</typeparam> /// <typeparam name="R">The result value type.</typeparam> /// <param name="transform">The function to map a source into another source.</param> /// <param name="waitSeconds">How many seconds to wait at most till the dispose reaches the upstream.</param> /// <remarks>Since 0.0.11</remarks> public static void VerifyDisposeSingle <T, R>(Func <ISingleSource <T>, ISingleSource <R> > transform, int waitSeconds = 1) { var ms = new SingleSubject <T>(); var source = transform(ms); var to = source.Test(); Assert.True(ms.HasObserver(), "Not subscribed to the source subject!"); to.Dispose(); for (int i = 0; i < waitSeconds * 10; i++) { if (ms.HasObserver()) { Thread.Sleep(100); } else { return; } } Assert.False(ms.HasObserver(), "Still subscribed to the source subject!"); }
public void Dispose() { var cs = new SingleSubject <int>(); var to = cs.Hide().Test(); Assert.True(cs.HasObserver()); to.Dispose(); Assert.False(cs.HasObserver()); }
public void Single_Dispose() { var ss = new SingleSubject <int>(); var to = ss.IgnoreElement().Test(); Assert.True(ss.HasObserver()); to.Dispose(); Assert.False(ss.HasObserver()); }
public void Normal_Dispose() { var cs = new SingleSubject <int>(); var to = new TestObserver <int>(); cs.SubscribeSafe(to); Assert.True(cs.HasObserver()); to.Dispose(); Assert.False(cs.HasObserver()); }
public void Single_Dispose_Other() { var ms = new SingleSubject <int>(); var to = CompletableSource.Empty() .AndThen(ms) .Test(); Assert.True(ms.HasObserver()); to.Dispose(); Assert.False(ms.HasObserver()); }
public void Disposed() { var up = new SingleSubject <int>(); IObservable <int> o = up.ToObservable <int>(); var to = o.Test(); Assert.True(up.HasObserver()); to.Dispose(); Assert.False(up.HasObserver()); }
public void Dispose() { var ms = new SingleSubject <int>(); var subj = new Subject <int>(); var to = ms.RetryWhen(v => subj).Test(); Assert.True(ms.HasObserver()); Assert.True(subj.HasObservers); to.Dispose(); Assert.False(ms.HasObserver()); Assert.False(subj.HasObservers); }
public void Other_Dispose() { var ts = new SingleSubject <int>(); var to = SingleSource.Just(1) .DelaySubscription(ts) .Test(); Assert.True(ts.HasObserver()); to.Dispose(); Assert.False(ts.HasObserver()); to.AssertEmpty(); }
public void Array_Max_Dispose() { var ms1 = new SingleSubject <int>(); var ms2 = new SingleSubject <int>(); var to = SingleSource.ConcatEager(ms1, ms2) .Test(); Assert.True(ms1.HasObserver()); Assert.True(ms2.HasObserver()); to.Dispose(); Assert.False(ms1.HasObserver()); Assert.False(ms2.HasObserver()); }
public void Dispose() { var count = 0; var ss = new SingleSubject <int>(); var d = ss .Subscribe(v => { count = v; }, e => { count = 2; }); Assert.True(ss.HasObserver()); d.Dispose(); Assert.False(ss.HasObserver()); Assert.AreEqual(0, count); }
public void Crash_OnSubscribe() { var cs = new SingleSubject <int>(); cs.SubscribeSafe(new FailingSingleObserver(true, true, true, true)); Assert.False(cs.HasObserver()); }
public void Handler_Completes_Prematurely() { var ms = new SingleSubject <int>(); var subj = new Subject <int>(); var to = ms.RepeatWhen(v => subj).Test(); Assert.True(ms.HasObserver()); Assert.True(subj.HasObservers); subj.OnCompleted(); Assert.False(ms.HasObserver()); Assert.False(subj.HasObservers); to.AssertResult(); }
public void Single_Dispose_Main() { var ss = new SingleSubject <int>(); var count = 0; var to = ss .FlatMap(v => CompletableSource.FromAction(() => count++)) .Test(); to.AssertSubscribed(); Assert.True(ss.HasObserver()); to.Dispose(); Assert.False(ss.HasObserver()); }
public void Handler_Completes_Prematurely() { var ms = new SingleSubject <int>(); var subj = new Subject <int>(); var to = ms.RetryWhen(v => subj).Test(); Assert.True(ms.HasObserver()); Assert.True(subj.HasObservers); subj.OnCompleted(); Assert.False(ms.HasObserver()); Assert.False(subj.HasObservers); to.AssertFailure(typeof(IndexOutOfRangeException)); }
public void Handler_Fails_Prematurely() { var ms = new SingleSubject <int>(); var subj = new Subject <int>(); var to = ms.RetryWhen(v => subj).Test(); Assert.True(ms.HasObserver()); Assert.True(subj.HasObservers); subj.OnError(new InvalidOperationException()); Assert.False(ms.HasObserver()); Assert.False(subj.HasObservers); to.AssertFailure(typeof(InvalidOperationException)); }
public void Limited_Eager_Error_First() { var ms1 = new SingleSubject <int>(); var ms2 = new SingleSubject <int>(); var to = new[] { ms1, ms2 }.ToObservable() .FlatMap(v => v, maxConcurrency: 1) .Test(); Assert.True(ms1.HasObserver()); Assert.False(ms2.HasObserver()); ms1.OnError(new InvalidOperationException()); Assert.False(ms2.HasObserver()); to.AssertFailure(typeof(InvalidOperationException)); }
public void Cancel() { var cts = new CancellationTokenSource(); var cs = new SingleSubject <int>(); var task = cs .ToTask(cts); Assert.True(cs.HasObserver()); Assert.False(task.IsCompleted); Assert.False(task.IsFaulted); cts.Cancel(); Assert.False(cs.HasObserver()); }
public void Array_Max_Error_Dispose_Second() { var ms1 = new SingleSubject <int>(); var ms2 = new SingleSubject <int>(); var to = SingleSource.ConcatEager(ms1, ms2) .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)); }