public void Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.TakeUntil(v => v == 3)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Overlap_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Window(3, 1)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Limited_Error_Main_Delayed()
{
var to = ObservableSource.Error <IObservableSource <int> >(new InvalidOperationException())
.Merge(true)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Other_Error_Main()
{
ObservableSource.Error <int>(new InvalidOperationException())
.DelaySubscription(ObservableSource.Range(6, 5))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Regular_Error()
{
ObservableSource.Error <int>(new InvalidOperationException()).Hide()
.ConcatMap(v => ObservableSource.Just(9 + v))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Exact_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Buffer(1)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Collect(() => new List <int>(), (a, b) => a.Add(b))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Fallback_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.OnErrorResumeNext(v => ObservableSource.Error <int>(new IndexOutOfRangeException()))
.Test()
.AssertFailure(typeof(IndexOutOfRangeException));
}
public void Main_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.OnErrorResumeNext(v => ObservableSource.Range(6, 5))
.Test()
.AssertResult(6, 7, 8, 9, 10);
}
public void Initial_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Reduce(() => 0, (a, b) => a + b)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Regular_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Map(v => v.ToString())
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Delay(v => ObservableSource.Empty <int>())
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Predicate_Basic_Wrong_Error()
{
ObservableSource.Range(1, 5).Concat(ObservableSource.Error <int>(new NotImplementedException()))
.Retry((e, c) => typeof(InvalidOperationException).IsAssignableFrom(e))
.Test()
.AssertFailure(typeof(NotImplementedException), 1, 2, 3, 4, 5);
}
public void Plain_Error_2()
{
ObservableSource.Error <int>(new InvalidOperationException())
.ElementAt(2)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Regular_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Filter(v => v % 2 == 0)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Default_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.ElementAt(0, 100)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error_Take_Zero()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Take(0)
.Test()
.AssertResult();
}
public void Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.SkipLast(2)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error_Inner()
{
ObservableSource.Range(1, 5)
.ConcatMapEager(v => ObservableSource.Error <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.ConcatMap(v => Enumerable.Range(v * 100, 5))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Other_Error()
{
ObservableSource.Never <int>()
.SkipUntil(ObservableSource.Error <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Counted_Basic_Retry_Twice()
{
ObservableSource.Range(1, 5).Concat(ObservableSource.Error <int>(new NotImplementedException()))
.Retry(2)
.Test()
.AssertFailure(typeof(NotImplementedException), 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5);
}
public void Regular_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.IgnoreElements()
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error_Fallback()
{
ObservableSource.Empty <int>()
.SwitchIfEmpty(ObservableSource.Error <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Predicate_Counted_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Repeat(count => count < 5)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void All_Error()
{
var success = 0;
var afterSuccess = 0;
var completed = 0;
var error = 0;
var terminate = 0;
var afterterminate = 0;
var subscribe = 0;
var dispose = 0;
var final = 0;
ObservableSource.Error <int>(new InvalidOperationException())
.DoOnNext(v => success++)
.DoAfterNext(v => afterSuccess++)
.DoOnCompleted(() => completed++)
.DoOnError(e => error++)
.DoOnTerminate(() => terminate++)
.DoAfterTerminate(() => afterterminate++)
.DoOnSubscribe(d => subscribe++)
.DoOnDispose(() => dispose++)
.DoFinally(() => final++)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(0, success);
Assert.AreEqual(0, afterSuccess);
Assert.AreEqual(0, completed);
Assert.AreEqual(1, error);
Assert.AreEqual(1, terminate);
Assert.AreEqual(1, afterterminate);
Assert.AreEqual(1, subscribe);
Assert.AreEqual(0, dispose);
Assert.AreEqual(1, final);
}
public void Time_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.Delay(TimeSpan.FromMilliseconds(10), ThreadPoolScheduler.Instance, false)
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertFailure(typeof(InvalidOperationException));
}
public void Error()
{
IObservable <int> source = ObservableSource.Error <int>(new InvalidOperationException())
.ToObservable();
source.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Limited_Error_Inner_Delayed()
{
var to = ObservableSource.Just <IObservableSource <int> >(
ObservableSource.Error <int>(new InvalidOperationException())).Hide()
.Merge(true, 1)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Fused_Error()
{
ObservableSource.Error <int>(new InvalidOperationException())
.IgnoreElements()
.Test(fusionMode: FusionSupport.Any)
.AssertFuseable()
.AssertFusionMode(FusionSupport.Async)
.AssertFailure(typeof(InvalidOperationException));
}
