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 Other_Error()
{
ObservableSource.Never <int>()
.SkipUntil(ObservableSource.Error <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Basic()
{
ObservableSource.Range(1, 5)
.SkipUntil(ObservableSource.Never <int>())
.Test()
.AssertResult();
}
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 Array_Basic_2()
{
ObservableSource.Amb(
ObservableSource.Never <int>(),
ObservableSource.Range(6, 5)
)
.Test()
.AssertResult(6, 7, 8, 9, 10);
}
public void Array_Error_2()
{
ObservableSource.Amb(
ObservableSource.Never <int>(),
ObservableSource.Error <int>(new InvalidOperationException())
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Array_Error_3()
{
ObservableSource.Amb(
ObservableSource.Never <int>(),
ObservableSource.Range(1, 5).ConcatError(new InvalidOperationException())
)
.Test()
.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5);
}
public void OnDispose_Basic()
{
var count = 0;
ObservableSource.Never <int>()
.DoOnDispose(() => count++)
.Test(true)
.AssertEmpty();
Assert.AreEqual(1, count);
}
public void Enumerable_Error_2()
{
ObservableSource.Amb(
new List <IObservableSource <int> >()
{
ObservableSource.Never <int>(),
ObservableSource.Error <int>(new InvalidOperationException())
}
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Enumerable_Basic_2()
{
ObservableSource.Amb(
new List <IObservableSource <int> >()
{
ObservableSource.Never <int>(),
ObservableSource.Range(6, 5)
}
)
.Test()
.AssertResult(6, 7, 8, 9, 10);
}
public void Lazy_Dispose_Crash()
{
var to = new TestObserver <int>(requireOnSubscribe: true);
ObservableSource.Using <int, int>(() => 1,
_ => ObservableSource.Never <int>(),
_ => throw new InvalidOperationException(), true)
.Subscribe(to);
to.Dispose();
to.AssertEmpty();
}
public void Timed_Fallback_Error()
{
var ts = new TestScheduler();
var to = ObservableSource.Never <int>()
.Timeout(TimeSpan.FromSeconds(1), ts, ObservableSource.Error <int>(new InvalidOperationException()))
.Test();
to.AssertEmpty();
ts.AdvanceTimeBy(1000);
to.AssertFailure(typeof(InvalidOperationException));
}
public void Timed_Timeout()
{
var ts = new TestScheduler();
var to = ObservableSource.Never <int>()
.Timeout(TimeSpan.FromSeconds(1), ts)
.Test();
to.AssertEmpty();
ts.AdvanceTimeBy(1000);
to.AssertFailure(typeof(TimeoutException));
}
public void Timed_Timeout_Fallback()
{
var ts = new TestScheduler();
var to = ObservableSource.Never <int>()
.Timeout(TimeSpan.FromSeconds(1), ts, ObservableSource.Range(6, 5))
.Test();
to.AssertEmpty();
ts.AdvanceTimeBy(1000);
to.AssertResult(6, 7, 8, 9, 10);
}
public void TrySingle_Timeout()
{
try
{
ObservableSource.Never <int>()
.BlockingTrySingle(out var _, TimeSpan.FromMilliseconds(20));
Assert.Fail("Should have thrown");
}
catch (TimeoutException)
{
// expected
}
}
public void TryLast_Cancel_Timeout()
{
var cts = new CancellationTokenSource();
try
{
ObservableSource.Never <int>()
.BlockingTryLast(out var _, TimeSpan.FromMilliseconds(20));
Assert.Fail("Should have thrown");
}
catch (TimeoutException)
{
// expected
}
}
public void OnDispose_Crash()
{
var count = 0;
ObservableSource.Never <int>()
.DoOnDispose(() =>
{
count++;
throw new InvalidOperationException();
})
.Test(true)
.AssertEmpty();
;
Assert.AreEqual(1, count);
}
public void First_Cancel()
{
var cts = new CancellationTokenSource();
cts.Cancel();
try
{
ObservableSource.Never <int>()
.BlockingFirst(cts);
Assert.Fail("Should have thrown");
}
catch (OperationCanceledException)
{
// expected
}
}
public void Timed_Dispose_Other()
{
var ts = new TestScheduler();
var source = new PublishSubject <int>();
var to = ObservableSource.Never <int>()
.Timeout(TimeSpan.FromSeconds(1), ts, source)
.Test();
Assert.False(source.HasObservers);
ts.AdvanceTimeBy(1000);
Assert.True(source.HasObservers);
to.Dispose();
Assert.False(source.HasObservers);
}
public void Basic()
{
ObservableSource.Never <int>()
.Test()
.AssertEmpty();
}
public void Lazy_Supplier_Crash()
{
var complete = 0;
ObservableSource.Using <int, int>(() => throw new InvalidOperationException(), v => ObservableSource.Never <int>(), _ => complete++, false)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(0, complete);
}
public void Dispose_First()
{
TestHelper.VerifyDisposeObservableSource <int, int>(o => o.Concat(ObservableSource.Never <int>()));
}