public void Time_Dispose_Other()
{
var ts = new TestScheduler();
var cs = new MaybeSubject <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 Array_Limited_Subscription_Empty()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = new[]
{
ms1,
ms2
}
.MergeAll(maxConcurrency: 1)
.Test();
Assert.True(ms1.HasObserver());
Assert.False(ms2.HasObserver());
ms1.OnCompleted();
Assert.False(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms2.OnCompleted();
to.AssertResult();
}
public void Limited_Delayed_Main_Completes_Inner_Succeeds()
{
for (int k = 1; k < 10; k++)
{
var subj = new Subject <int>();
var ms = new MaybeSubject <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 Maybe_Dispose_Inner()
{
var ss = new MaybeSubject <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 Enumerable_Limited_Subscription_Empty()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = new List <IMaybeSource <int> >()
{
ms1,
ms2
}
.Merge(maxConcurrency: 1)
.Test();
Assert.True(ms1.HasObserver());
Assert.False(ms2.HasObserver());
ms1.OnCompleted();
Assert.False(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms2.OnCompleted();
to.AssertResult();
}
public void Timeout_Fallback_Error()
{
var ts = new TestScheduler();
var us = new MaybeSubject <int>();
var count = 0;
var fb = MaybeSource.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 Enumerable_Limit_Max_Concurrency()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.ConcatEager(
new List <IMaybeSource <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 Value_Cancel_Wait()
{
var cs = new MaybeSubject <int>();
var cts = new CancellationTokenSource();
try
{
Task.Factory.StartNew(() =>
{
while (!cs.HasObserver())
{
;
}
Thread.Sleep(100);
cts.Cancel();
});
cs
.Wait(out var v, cts: cts);
Assert.Fail();
}
catch (OperationCanceledException)
{
// expected
}
Assert.False(cs.HasObserver());
}
public void Timeout_Fallback_Success()
{
var ts = new TestScheduler();
var us = new MaybeSubject <int>();
var count = 0;
var fb = MaybeSource.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 Observer_Dispose()
{
for (int i = 0; i < TestHelper.RACE_LOOPS; i++)
{
var cs = new MaybeSubject <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 Limited_Eager_Main_Completes_Inner_Empty()
{
for (int k = 1; k < 10; k++)
{
var subj = new Subject <int>();
var ms = new MaybeSubject <int>();
var to = subj.FlatMap(v => ms, maxConcurrency: k).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 Limited_Delayed_Dispose_Inner_Error()
{
for (int k = 1; k < 10; k++)
{
var subj = new Subject <int>();
var ms = new MaybeSubject <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));
}
}
/// <summary>
/// Calls a transform function with an MaybeSubject,
/// subscribes to the resulting IMaybeSource, disposes
/// the connection and verifies if the MaybeSubject
/// 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 VerifyDisposeMaybe <T, R>(Func <IMaybeSource <T>, ISingleSource <R> > transform, int waitSeconds = 1)
{
var ms = new MaybeSubject <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 Inner_Error_Delayed()
{
var subj = new Subject <int>();
var ms = new MaybeSubject <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 Dispose()
{
var cs = new MaybeSubject <int>();
var to = cs.Hide().Test();
Assert.True(cs.HasObserver());
to.Dispose();
Assert.False(cs.HasObserver());
}
public void Maybe_Dispose()
{
var ss = new MaybeSubject <int>();
var to = ss.IgnoreElement().Test();
Assert.True(ss.HasObserver());
to.Dispose();
Assert.False(ss.HasObserver());
}
public void Normal_Dispose()
{
var cs = new MaybeSubject <int>();
var to = new TestObserver <int>();
cs.SubscribeSafe(to);
Assert.True(cs.HasObserver());
to.Dispose();
Assert.False(cs.HasObserver());
}
public void Maybe_Dispose_Other()
{
var ms = new MaybeSubject <int>();
var to = CompletableSource.Empty()
.AndThen(ms)
.Test();
Assert.True(ms.HasObserver());
to.Dispose();
Assert.False(ms.HasObserver());
}
public void Disposed()
{
var up = new MaybeSubject <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 MaybeSubject <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 Array_Max_Dispose()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.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 MaybeSubject <int>();
var d = ss
.Subscribe(v => { count = v; }, e => { count = 2; }, () => { count = 3; });
Assert.True(ss.HasObserver());
d.Dispose();
Assert.False(ss.HasObserver());
Assert.AreEqual(0, count);
}
public void Other_Dispose()
{
var ts = new MaybeSubject <int>();
var to = MaybeSource.Empty <int>()
.DelaySubscription(ts)
.Test();
Assert.True(ts.HasObserver());
to.Dispose();
Assert.False(ts.HasObserver());
to.AssertEmpty();
}
public void Handler_Fails_Prematurely()
{
var ms = new MaybeSubject <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 Handler_Completes_Prematurely()
{
var ms = new MaybeSubject <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.AssertResult();
}
public void Crash_OnSubscribe()
{
var cs = new MaybeSubject <int>();
cs.SubscribeSafe(new FailingMaybeObserver(true, true, true, true));
Assert.False(cs.HasObserver());
}
public void Maybe_Dispose_Main()
{
var ss = new MaybeSubject <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 Limited_Eager_Error_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.OnError(new InvalidOperationException());
Assert.False(ms2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException));
}
public void Cancel()
{
var cts = new CancellationTokenSource();
var cs = new MaybeSubject <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 MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.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));
}
