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);
}
