public void ConnectableObservable_Connected()
{
var scheduler = new TestScheduler();
var xs = scheduler.CreateHotObservable<int>(
OnNext(210, 1),
OnNext(220, 2),
OnNext(230, 3),
OnNext(240, 4),
OnCompleted<int>(250)
);
var subject = new MySubject();
var conn = new ConnectableObservable<int>(xs, subject);
var disconnect = conn.Connect();
var res = scheduler.Start(() => conn);
res.Messages.AssertEqual(
OnNext(210, 1),
OnNext(220, 2),
OnNext(230, 3),
OnNext(240, 4),
OnCompleted<int>(250)
);
}
public void ConnectableObservable_Creation()
{
var y = 0;
var s2 = new Subject<int>();
var co2 = new ConnectableObservable<int>(Observable.Return<int>(1), s2);
co2.Subscribe(x => y = x);
Assert.AreNotEqual(1, y);
co2.Connect();
Assert.AreEqual(1, y);
}
public void connecting_multiple_times_does_not_subscribe_to_source_multiple_times()
{
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> source = new StatsSubject<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
var sub = connectable.Subscribe(stats);
connectable.Connect();
connectable.Connect();
Assert.AreEqual(1, source.SubscriptionCount);
}
public void connecting_multiple_times_does_not_subscribe_to_source_multiple_times()
{
StatsObserver <int> stats = new StatsObserver <int>();
StatsSubject <int> source = new StatsSubject <int>();
StatsSubject <int> subject = new StatsSubject <int>();
ConnectableObservable <int> connectable = new ConnectableObservable <int>(source, subject);
var sub = connectable.Subscribe(stats);
connectable.Connect();
connectable.Connect();
Assert.AreEqual(1, source.SubscriptionCount);
}
public void connecting_subscribes_to_source()
{
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> source = new StatsSubject<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
var sub = connectable.Subscribe(stats);
Assert.IsFalse(source.HasSubscriptions);
connectable.Connect();
Assert.IsTrue(source.HasSubscriptions);
}
public void disconnecting_subscribes_to_source()
{
StatsObserver <int> stats = new StatsObserver <int>();
StatsSubject <int> source = new StatsSubject <int>();
StatsSubject <int> subject = new StatsSubject <int>();
ConnectableObservable <int> connectable = new ConnectableObservable <int>(source, subject);
var sub = connectable.Subscribe(stats);
Assert.IsFalse(source.HasSubscriptions);
connectable.Connect().Dispose();
Assert.IsFalse(source.HasSubscriptions);
}
public void values_send_before_completion_are_ignored()
{
StatsObserver <int> stats = new StatsObserver <int>();
StatsSubject <int> source = new StatsSubject <int>();
StatsSubject <int> subject = new StatsSubject <int>();
ConnectableObservable <int> connectable = new ConnectableObservable <int>(source, subject);
var sub = connectable.Subscribe(stats);
source.OnNext(0);
source.OnCompleted();
source.OnError(new Exception());
Assert.IsFalse(stats.NextCalled);
Assert.IsFalse(stats.CompletedCalled);
Assert.IsFalse(stats.ErrorCalled);
}
public void disconnecting_does_not_remove_subscriptions()
{
IObservable <int> source = Observable.Empty <int>();
StatsObserver <int> stats = new StatsObserver <int>();
StatsSubject <int> subject = new StatsSubject <int>();
ConnectableObservable <int> connectable = new ConnectableObservable <int>(source, subject);
Assert.IsFalse(subject.HasSubscriptions);
var sub = connectable.Subscribe(stats);
Assert.IsTrue(subject.HasSubscriptions);
connectable.Connect().Dispose();
Assert.IsTrue(subject.HasSubscriptions);
}
public void uses_subject_for_subscriptions()
{
IObservable <int> source = Observable.Empty <int>();
StatsObserver <int> stats = new StatsObserver <int>();
StatsSubject <int> subject = new StatsSubject <int>();
ConnectableObservable <int> connectable = new ConnectableObservable <int>(source, subject);
Assert.IsFalse(subject.HasSubscriptions);
var sub = connectable.Subscribe(stats);
Assert.IsTrue(subject.HasSubscriptions);
sub.Dispose();
Assert.IsFalse(subject.HasSubscriptions);
}
public void disconnecting_does_not_remove_subscriptions()
{
IObservable<int> source = Observable.Empty<int>();
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
Assert.IsFalse(subject.HasSubscriptions);
var sub = connectable.Subscribe(stats);
Assert.IsTrue(subject.HasSubscriptions);
connectable.Connect().Dispose();
Assert.IsTrue(subject.HasSubscriptions);
}
public void disconnecting_first_of_multiple_connections_subscribes_to_source()
{
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> source = new StatsSubject<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
var sub = connectable.Subscribe(stats);
Assert.IsFalse(source.HasSubscriptions);
var connectionA = connectable.Connect();
var connectionB = connectable.Connect();
connectionA.Dispose();
Assert.IsFalse(source.HasSubscriptions);
}
public void Run(Multicast <TSource, TIntermediate, TResult> parent)
{
IObservable <TResult> observable;
IConnectableObservable <TIntermediate> connectable;
try
{
var subject = parent._subjectSelector();
connectable = new ConnectableObservable <TSource, TIntermediate>(parent._source, subject);
observable = parent._selector(connectable);
}
catch (Exception exception)
{
ForwardOnError(exception);
return;
}
Run(observable);
_connection.Disposable = connectable.Connect();
}
public void Run(Multicast <TSource, TIntermediate, TResult> parent)
{
var observable = default(IObservable <TResult>);
var connectable = default(IConnectableObservable <TIntermediate>);
try
{
var subject = parent._subjectSelector();
connectable = new ConnectableObservable <TSource, TIntermediate>(parent._source, subject);
observable = parent._selector(connectable);
}
catch (Exception exception)
{
ForwardOnError(exception);
return;
}
Run(observable);
Disposable.SetSingle(ref _connection, connectable.Connect());
}
public void operation_order_is_honoured_prior_to_connection()
{
StatsObserver <int> stats = new StatsObserver <int>();
StatsSubject <int> source = new StatsSubject <int>();
StatsSubject <int> subject = new StatsSubject <int>();
ConnectableObservable <int> connectable = new ConnectableObservable <int>(source, subject);
var sub = connectable.Subscribe(stats);
source.OnNext(0);
source.OnCompleted();
connectable.Connect();
source.OnNext(1);
Assert.IsFalse(stats.NextCalled);
Assert.IsFalse(stats.CompletedCalled);
Assert.IsFalse(stats.ErrorCalled);
}
public void operations_are_passed_on_once_connected()
{
StatsObserver <int> stats = new StatsObserver <int>();
StatsSubject <int> source = new StatsSubject <int>();
StatsSubject <int> subject = new StatsSubject <int>();
ConnectableObservable <int> connectable = new ConnectableObservable <int>(source, subject);
var sub = connectable.Subscribe(stats);
source.OnNext(0);
connectable.Connect();
source.OnNext(1);
Assert.IsTrue(stats.NextCalled);
Assert.AreEqual(1, stats.NextValues[0]);
Assert.IsFalse(stats.CompletedCalled);
Assert.IsFalse(stats.ErrorCalled);
}
public IDisposable Run(Multicast <TSource, TIntermediate, TResult> parent)
{
var observable = default(IObservable <TResult>);
var connectable = default(IConnectableObservable <TIntermediate>);
try
{
var subject = parent._subjectSelector();
connectable = new ConnectableObservable <TSource, TIntermediate>(parent._source, subject);
observable = parent._selector(connectable);
}
catch (Exception exception)
{
ForwardOnError(exception);
return(Disposable.Empty);
}
var subscription = observable.SubscribeSafe(this);
var connection = connectable.Connect();
return(StableCompositeDisposable.Create(subscription, connection));
}
public IDisposable Run()
{
var observable = default(IObservable <TResult>);
var connectable = default(IConnectableObservable <TIntermediate>);
try
{
var subject = _parent._subjectSelector();
connectable = new ConnectableObservable <TSource, TIntermediate>(_parent._source, subject);
observable = _parent._selector(connectable);
}
catch (Exception exception)
{
base._observer.OnError(exception);
base.Dispose();
return(Disposable.Empty);
}
var subscription = observable.SubscribeSafe(this);
var connection = connectable.Connect();
return(new CompositeDisposable(subscription, connection));
}
public void uses_subject_for_subscriptions()
{
IObservable<int> source = Observable.Empty<int>();
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
Assert.IsFalse(subject.HasSubscriptions);
var sub = connectable.Subscribe(stats);
Assert.IsTrue(subject.HasSubscriptions);
sub.Dispose();
Assert.IsFalse(subject.HasSubscriptions);
}
public Connection(ConnectableObservable <T> parent, IDisposable subscription)
{
this.parent = parent;
this.subscription = subscription;
}
public void RefCount_NotConnected()
{
var disconnected = false;
var count = 0;
var xs = Observable.Defer(() =>
{
count++;
return Observable.Create<int>(obs =>
{
return () => { disconnected = true; };
});
});
var subject = new MySubject();
var conn = new ConnectableObservable<int>(xs, subject);
var refd = conn.RefCount();
var dis1 = refd.Subscribe();
Assert.AreEqual(1, count);
Assert.AreEqual(1, subject.SubscribeCount);
Assert.IsFalse(disconnected);
var dis2 = refd.Subscribe();
Assert.AreEqual(1, count);
Assert.AreEqual(2, subject.SubscribeCount);
Assert.IsFalse(disconnected);
dis1.Dispose();
Assert.IsFalse(disconnected);
dis2.Dispose();
Assert.IsTrue(disconnected);
disconnected = false;
var dis3 = refd.Subscribe();
Assert.AreEqual(2, count);
Assert.AreEqual(3, subject.SubscribeCount);
Assert.IsFalse(disconnected);
dis3.Dispose();
Assert.IsTrue(disconnected);
}
public void RefCount_ConnectsOnFirst()
{
var scheduler = new TestScheduler();
var xs = scheduler.CreateHotObservable<int>(
OnNext(210, 1),
OnNext(220, 2),
OnNext(230, 3),
OnNext(240, 4),
OnCompleted<int>(250)
);
var subject = new MySubject();
var conn = new ConnectableObservable<int>(xs, subject);
var res = scheduler.Start(() =>
conn.RefCount()
);
res.Messages.AssertEqual(
OnNext(210, 1),
OnNext(220, 2),
OnNext(230, 3),
OnNext(240, 4),
OnCompleted<int>(250)
);
Assert.IsTrue(subject.Disposed);
}
public void operations_are_passed_on_once_connected()
{
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> source = new StatsSubject<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
var sub = connectable.Subscribe(stats);
source.OnNext(0);
connectable.Connect();
source.OnNext(1);
Assert.IsTrue(stats.NextCalled);
Assert.AreEqual(1, stats.NextValues[0]);
Assert.IsFalse(stats.CompletedCalled);
Assert.IsFalse(stats.ErrorCalled);
}
public void operation_order_is_honoured_prior_to_connection()
{
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> source = new StatsSubject<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
var sub = connectable.Subscribe(stats);
source.OnNext(0);
source.OnCompleted();
connectable.Connect();
source.OnNext(1);
Assert.IsFalse(stats.NextCalled);
Assert.IsFalse(stats.CompletedCalled);
Assert.IsFalse(stats.ErrorCalled);
}
public void values_send_before_completion_are_ignored()
{
StatsObserver<int> stats = new StatsObserver<int>();
StatsSubject<int> source = new StatsSubject<int>();
StatsSubject<int> subject = new StatsSubject<int>();
ConnectableObservable<int> connectable = new ConnectableObservable<int>(source, subject);
var sub = connectable.Subscribe(stats);
source.OnNext(0);
source.OnCompleted();
source.OnError(new Exception());
Assert.IsFalse(stats.NextCalled);
Assert.IsFalse(stats.CompletedCalled);
Assert.IsFalse(stats.ErrorCalled);
}
