public void Right_Error()
{
var left = new PublishSubject <int>();
var right = new PublishSubject <int>();
var to = left.Join(right,
a => ObservableSource.Never <int>(),
b => ObservableSource.Never <int>(),
(a, b) => a + b)
.Test();
to.AssertEmpty();
left.OnNext(1);
right.OnNext(100);
to.AssertValuesOnly(101);
right.OnError(new InvalidOperationException());
to.AssertFailure(typeof(InvalidOperationException), 101);
Assert.False(left.HasObservers);
Assert.False(right.HasObservers);
}
public void Basic()
{
var left = new PublishSubject <int>();
var right = new PublishSubject <int>();
var to = left.Join(right,
a => ObservableSource.Never <int>(),
b => ObservableSource.Never <int>(),
(a, b) => a + b)
.Test();
to.AssertEmpty();
left.OnNext(1);
right.OnNext(100);
to.AssertValuesOnly(101);
left.OnNext(2);
to.AssertValuesOnly(101, 102);
right.OnNext(200);
to.AssertValuesOnly(101, 102, 201, 202);
left.OnCompleted();
to.AssertValuesOnly(101, 102, 201, 202);
right.OnCompleted();
to.AssertResult(101, 102, 201, 202);
}
public void Result_Selector_Crash()
{
var left = new PublishSubject <int>();
var right = new PublishSubject <int>();
var leftEnd = new PublishSubject <int>();
var rightEnd = new PublishSubject <int>();
var to = left.Join <int, int, int, int, int>(right,
a => leftEnd,
b => rightEnd,
(a, b) => throw new InvalidOperationException())
.Test();
to.AssertEmpty();
left.OnNext(1);
right.OnNext(100);
to.AssertFailure(typeof(InvalidOperationException));
Assert.False(left.HasObservers);
Assert.False(right.HasObservers);
Assert.False(leftEnd.HasObservers);
Assert.False(rightEnd.HasObservers);
}
public void Take_One_Group()
{
var subj = new PublishSubject <int>();
var group = new List <IGroupedObservableSource <int, int> >();
var d = subj.GroupBy(v => 1).Subscribe(v => group.Add(v));
Assert.True(subj.HasObservers);
Assert.AreEqual(0, group.Count);
subj.OnNext(1);
Assert.AreEqual(1, group.Count);
d.Dispose();
Assert.True(subj.HasObservers);
subj.OnNext(2);
Assert.AreEqual(1, group.Count);
var to = group[0].Test();
to.AssertValuesOnly(1, 2);
to.Dispose();
Assert.False(subj.HasObservers);
}
public void AutoConnect_Dispose()
{
var subject = new PublishSubject <int>();
var disposable = new IDisposable[1];
var source = subject
.Replay()
.AutoConnect(1, d => disposable[0] = d);
Assert.Null(disposable[0]);
var list = new List <int>();
source.Subscribe(v => list.Add(v));
Assert.NotNull(disposable[0]);
subject.OnNext(1);
subject.OnNext(2);
subject.OnNext(3);
disposable[0].Dispose();
subject.OnNext(4);
subject.OnNext(5);
Assert.AreEqual(new List <int>()
{
1, 2, 3
}, list);
}
public void Dispose()
{
var subj = new PublishSubject <int>();
var to = subj.SubscribeOn(ThreadPoolScheduler.Instance)
.Test();
int cnt = 0;
while (!subj.HasObservers)
{
if (++cnt == 5000)
{
Assert.Fail("No observers showed up?!");
}
Thread.Sleep(1);
}
subj.OnNext(1);
to.AssertValuesOnly(1);
subj.OnNext(2);
to.AssertValuesOnly(1, 2);
to.Dispose();
Assert.False(subj.HasObservers);
}
public void False_Disposes()
{
var ps = new PublishSubject <int>();
var to = ps
.TakeUntil(v => v == 4)
.Test();
Assert.True(ps.HasObservers);
ps.OnNext(1);
Assert.True(ps.HasObservers);
to.AssertValuesOnly(1);
ps.OnNext(2);
Assert.True(ps.HasObservers);
to.AssertValuesOnly(1, 2);
ps.OnNext(3);
Assert.True(ps.HasObservers);
to.AssertValuesOnly(1, 2, 3);
ps.OnNext(4);
Assert.False(ps.HasObservers);
to.AssertResult(1, 2, 3, 4);
}
public void Main_Disposes_Others_On_Error()
{
var us1 = new MonocastSubject <int>();
var us2 = new MonocastSubject <int>();
us1.Emit(10);
us2.Emit(100);
var source = new PublishSubject <int>();
var to = source.WithLatestFrom((a, bs) =>
{
foreach (var i in bs)
{
a += i;
}
return(a);
}, us1, us2).Test();
Assert.True(us1.HasObserver());
Assert.True(us2.HasObserver());
to.AssertEmpty();
source.EmitError(new InvalidOperationException(), 1, 2, 3, 4, 5);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException), 111, 112, 113, 114, 115);
}
public void Switch_Outer_Completes_First()
{
var source = new PublishSubject <IObservableSource <int> >();
var to = source.Switch().Test();
to.AssertEmpty();
var us1 = new MonocastSubject <int>();
source.OnNext(us1);
Assert.True(us1.HasObserver());
var us2 = new MonocastSubject <int>();
source.OnNext(us2);
Assert.True(us2.HasObserver());
Assert.False(us1.HasObserver());
source.OnCompleted();
Assert.True(us2.HasObserver());
to.AssertEmpty();
us2.EmitAll(1, 2, 3, 4, 5);
to.AssertResult(1, 2, 3, 4, 5);
}
public void Error()
{
var ps = new PublishSubject <int>();
Assert.False(ps.HasObservers);
Assert.False(ps.HasCompleted());
Assert.False(ps.HasException());
Assert.Null(ps.GetException());
var to1 = ps.Test();
var ex = new InvalidOperationException();
ps.OnNext(1);
ps.OnNext(2);
ps.OnNext(3);
ps.OnError(ex);
to1.AssertFailure(typeof(InvalidOperationException), 1, 2, 3);
Assert.False(ps.HasObservers);
Assert.False(ps.HasCompleted());
Assert.True(ps.HasException());
Assert.AreEqual(ex, ps.GetException());
ps.Test().AssertFailure(typeof(InvalidOperationException));
}
public void Regular_Regular_Error_Delayed()
{
for (int i = 0; i < 2; i++)
{
var ts = new TestScheduler();
var subj = new PublishSubject <int>();
var to = subj.ObserveOn(ts, true, fair: i == 0)
.Test()
.WithTag($"fair={i == 0}");
Assert.True(subj.HasObservers);
to.AssertEmpty();
subj.OnNext(1);
subj.OnNext(2);
subj.OnError(new InvalidOperationException());
to.AssertEmpty();
ts.AdvanceTimeBy(1);
to.AssertFailure(typeof(InvalidOperationException), 1, 2);
}
}
/// <summary>
/// Calls a transform function with a PublishSubject,
/// subscribes to the resulting IObservable, disposes
/// the connection and verifies if the Subject
/// 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 VerifyDisposeObservableSource <T, R>(Func <IObservableSource <T>, IObservable <R> > transform, int waitSeconds = 1)
{
var ms = new PublishSubject <T>();
var source = transform(ms);
var to = source.Test();
Assert.True(ms.HasObservers, "Not subscribed to the source subject!");
to.Dispose();
for (int i = 0; i < waitSeconds * 10; i++)
{
if (ms.HasObservers)
{
Thread.Sleep(100);
}
else
{
return;
}
}
Assert.False(ms.HasObservers, "Still subscribed to the source subject!");
}
public void Limited_Dispose()
{
for (int i = 1; i < 7; i++)
{
var subj = new PublishSubject <int>();
var inner = new PublishSubject <int>();
var to = subj.FlatMap(v => inner, maxConcurrency: i).Test();
to.WithTag($"maxConcurrency: {i}")
.AssertEmpty();
Assert.True(subj.HasObservers);
Assert.False(inner.HasObservers);
subj.OnNext(1);
Assert.True(subj.HasObservers);
Assert.True(inner.HasObservers);
to.Dispose();
Assert.False(subj.HasObservers);
Assert.False(inner.HasObservers);
}
}
public void Step()
{
var subj = new PublishSubject <int>();
var ts = new TestScheduler();
var to = subj.TakeLast(TimeSpan.FromMilliseconds(500), ts)
.Test();
to.AssertEmpty();
subj.OnNext(1);
ts.AdvanceTimeBy(200);
subj.OnNext(2);
ts.AdvanceTimeBy(200);
subj.OnNext(3);
ts.AdvanceTimeBy(200);
subj.OnNext(4);
ts.AdvanceTimeBy(200);
to.AssertEmpty();
subj.OnCompleted();
to.AssertResult(3, 4);
}
public void Replay_Timeout_Revive()
{
var ts = new TestScheduler();
var subj = new PublishSubject <int>();
var src = subj.Replay().RefCount(TimeSpan.FromSeconds(1), ts);
Assert.False(subj.HasObservers);
var to = src.Test();
Assert.True(subj.HasObservers);
to.Dispose();
Assert.True(subj.HasObservers);
ts.AdvanceTimeBy(500);
var to2 = src.Test();
ts.AdvanceTimeBy(500);
Assert.True(subj.HasObservers);
subj.OnCompleted();
Assert.False(ts.HasTasks());
}
public void Error_Main_Disposes_Inner()
{
var subj = new PublishSubject <int>();
var inner = new PublishSubject <int>();
var to = subj.Delay(v => inner).Test();
Assert.True(subj.HasObservers);
Assert.False(inner.HasObservers);
to.AssertEmpty();
subj.OnNext(1);
to.AssertEmpty();
Assert.True(subj.HasObservers);
Assert.True(inner.HasObservers);
subj.OnError(new InvalidOperationException());
to.AssertFailure(typeof(InvalidOperationException));
Assert.False(subj.HasObservers);
Assert.False(inner.HasObservers);
}
public void SingleTask_Multiple_Dispose()
{
var subj = new PublishSubject <int>();
var task = subj.SingleTask();
Assert.True(subj.HasObservers);
subj.OnNext(1);
Assert.True(subj.HasObservers);
Assert.False(task.IsCompleted);
Assert.False(task.IsCanceled);
Assert.False(task.IsFaulted);
subj.OnNext(2);
Assert.False(subj.HasObservers);
Assert.True(task.IsCompleted);
Assert.False(task.IsCanceled);
Assert.True(task.IsFaulted);
Assert.True(typeof(IndexOutOfRangeException).IsAssignableFrom((task.Exception as AggregateException).InnerExceptions[0]));
}
public void Main_Disposes_Others_On_Completion()
{
var us1 = new MonocastSubject <int>();
var us2 = new MonocastSubject <int>();
us1.Emit(10);
us2.Emit(100);
var source = new PublishSubject <int>();
var to = source.WithLatestFrom((a, bs) =>
{
foreach (var i in bs)
{
a += i;
}
return(a);
}, us1, us2).Test();
Assert.True(us1.HasObserver());
Assert.True(us2.HasObserver());
to.AssertEmpty();
source.EmitAll(1, 2, 3, 4, 5);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertResult(111, 112, 113, 114, 115);
}
public void Limited_Array_Step()
{
var subj1 = new PublishSubject <int>();
var subj2 = new PublishSubject <int>();
var to = ObservableSource.Merge(1, subj1, subj2)
.Test();
to.AssertEmpty();
Assert.True(subj1.HasObservers);
Assert.False(subj2.HasObservers);
subj1.OnCompleted();
to.AssertEmpty();
Assert.False(subj1.HasObservers);
Assert.True(subj2.HasObservers);
subj2.OnCompleted();
Assert.False(subj1.HasObservers);
Assert.False(subj2.HasObservers);
to.AssertResult();
}
public void Basic()
{
var ts = new TestScheduler();
var subj = new PublishSubject <int>();
var to = subj.SkipLast(TimeSpan.FromSeconds(5), ts).Test();
to.AssertEmpty();
subj.OnNext(1);
ts.AdvanceTimeBy(1000);
to.AssertEmpty();
subj.OnNext(2);
ts.AdvanceTimeBy(4000);
subj.OnNext(3);
to.AssertValuesOnly(1);
ts.AdvanceTimeBy(1000);
subj.OnNext(4);
to.AssertValuesOnly(1, 2);
subj.OnCompleted();
to.AssertResult(1, 2);
}
public void Time_Step()
{
var ts = new TestScheduler();
var subj = new PublishSubject <int>();
var to = subj.Delay(v => ObservableSource.Timer(TimeSpan.FromSeconds(1), ts)).Test();
subj.OnNext(1);
subj.OnNext(2);
Assert.True(ts.HasTasks());
to.AssertEmpty();
ts.AdvanceTimeBy(1000);
to.AssertValuesOnly(1, 2);
ts.AdvanceTimeBy(1000);
to.AssertValuesOnly(1, 2);
subj.OnNext(3);
ts.AdvanceTimeBy(200);
subj.OnNext(4);
ts.AdvanceTimeBy(200);
subj.OnNext(5);
ts.AdvanceTimeBy(200);
to.AssertValuesOnly(1, 2);
ts.AdvanceTimeBy(400);
to.AssertValuesOnly(1, 2, 3);
ts.AdvanceTimeBy(200);
to.AssertValuesOnly(1, 2, 3, 4);
ts.AdvanceTimeBy(200);
to.AssertValuesOnly(1, 2, 3, 4, 5);
subj.OnCompleted();
ts.AdvanceTimeBy(500);
to.AssertResult(1, 2, 3, 4, 5);
Assert.False(ts.HasTasks());
}
public void OnSubscribe_Crash()
{
var ps = new PublishSubject <int>();
var error = default(Exception);
var d = ps.Subscribe(onSubscribe: v => throw new InvalidOperationException(), onError: e => error = e);
Assert.False(ps.HasObservers);
Assert.True(typeof(InvalidOperationException).IsAssignableFrom(error.GetType()));
}
public void Race()
{
for (int i = 0; i < TestHelper.RACE_LOOPS; i++)
{
var subj = new PublishSubject <int>();
var o = subj.Cache();
var to1 = o.Test();
var to2 = new TestObserver <int>();
TestHelper.Race(
() =>
{
for (int j = 0; j < 1000; j++)
{
subj.OnNext(j);
}
subj.OnCompleted();
},
() =>
{
while (to1.ItemCount < 250)
{
;
}
o.Subscribe(to2);
}
);
to1.AssertValueCount(1000)
.AssertNoError()
.AssertCompleted();
var list = to1.Items;
for (int j = 0; j < 1000; j++)
{
Assert.AreEqual(j, list[j]);
}
to2
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertValueCount(1000)
.AssertNoError()
.AssertCompleted();
list = to2.Items;
for (int j = 0; j < 1000; j++)
{
Assert.AreEqual(j, list[j]);
}
}
}
public void OnError_Crash()
{
var ps = new PublishSubject <int>();
var d = ps.Subscribe(onError: v => throw new InvalidOperationException());
Assert.True(ps.HasObservers);
ps.OnError(new IndexOutOfRangeException());
Assert.False(ps.HasObservers);
}
public void OnCompleted_Crash()
{
var ps = new PublishSubject <int>();
var d = ps.Subscribe(onCompleted: () => throw new InvalidOperationException());
Assert.True(ps.HasObservers);
ps.OnCompleted();
Assert.False(ps.HasObservers);
}
public void Dispose_Upfront()
{
var subj = new PublishSubject <int>();
var src = subj.Cache();
Assert.False(subj.HasObservers);
src.Test(true).AssertEmpty();
Assert.False(subj.HasObservers);
}
public void Dispose()
{
var ps = new PublishSubject <int>();
var d = ps.Subscribe();
Assert.True(ps.HasObservers);
d.Dispose();
Assert.False(ps.HasObservers);
}
public void TestSimplePasses()
{
var sub = new PublishSubject <int>();
sub.Where(v => v > 3)
.Select(v => v.ToString())
.Subscribe(v => Debug.Log("result:" + v));
sub.OnNext(1);
sub.OnNext(3);
sub.OnNext(9);
}
public void AddTask(IObservable <T> observable)
{
if (_lastObservable == null)
{
_head = new PublishSubject <T>();
_lastObservable = _head;
}
else
{
var last = _lastObservable.ContinueWith(v => observable);
_lastObservable = last;
}
}
public void Lazy_Dispose_Cleanup()
{
var complete = -1;
var subj = new PublishSubject <int>();
var to = new TestObserver <int>(requireOnSubscribe: true);
ObservableSource.Using(() => 0, _ => subj, _ => complete = subj.HasObservers ? 1 : 0, false)
.Subscribe(to);
to.Dispose();
Assert.AreEqual(1, complete);
}
