public void Times_Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.Repeat()
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Enumerable_Limit_Error_Stop()
{
for (int i = 1; i < 10; i++)
{
var count = 0;
var src = SingleSource.FromFunc(() => ++ count);
var to = new List <ISingleSource <int> >()
{
SingleSource.Just(1),
SingleSource.Error <int>(new InvalidOperationException()),
src
}
.ConcatEager(maxConcurrency: i)
.Test();
if (i >= 2)
{
to.AssertFailure(typeof(InvalidOperationException));
}
else
{
to.AssertFailure(typeof(InvalidOperationException), 1);
}
Assert.AreEqual(0, count);
}
}
public void Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.OnTerminateDetach()
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void All_Error()
{
var success = 0;
var afterSuccess = 0;
var error = 0;
var terminate = 0;
var afterterminate = 0;
var subscribe = 0;
var dispose = 0;
var final = 0;
SingleSource.Error <int>(new InvalidOperationException())
.DoOnSuccess(v => success++)
.DoOnSuccess(v => afterSuccess++)
.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(1, error);
Assert.AreEqual(1, terminate);
Assert.AreEqual(1, afterterminate);
Assert.AreEqual(1, subscribe);
Assert.AreEqual(0, dispose);
Assert.AreEqual(1, final);
}
public void Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.Timeout(TimeSpan.FromMinutes(1), NewThreadScheduler.Default)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Single_Error_Inner()
{
SingleSource.Just(1)
.FlatMap(v => SingleSource.Error <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Dispose_Fallback()
{
TestHelper.VerifyDisposeSingle <int, int>(m =>
SingleSource.Error <int>(new InvalidOperationException())
.OnErrorResumeNext(m)
);
}
public void Error()
{
IMaybeSource <int> src = SingleSource.Error <int>(new InvalidOperationException())
.ToMaybe();
src.Test().AssertFailure(typeof(InvalidOperationException));
}
public void Single_Next_Error()
{
CompletableSource.Empty()
.AndThen(SingleSource.Error <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.Filter(v => true)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Single_Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.IgnoreElement()
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Limit_Error_Stop()
{
for (int i = 1; i < 10; i++)
{
var count = 0;
var src = SingleSource.FromFunc(() => ++ count);
var to = new []
{
SingleSource.Just(1),
SingleSource.Error <int>(new InvalidOperationException()),
src
}.ToObservable()
.ConcatEager(maxConcurrency: i)
.Test();
to
.AssertNotCompleted()
.AssertError(typeof(InvalidOperationException));
Assert.AreEqual(0, count);
}
}
public void Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.Map(v => "" + (v + 1))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Single_Error_Fallback()
{
MaybeSource.Empty <int>()
.SwitchIfEmpty(SingleSource.Error <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error()
{
// do not make this var to ensure the target type is correct
IObservable <int> o = SingleSource.Error <int>(new InvalidOperationException()).ToObservable <int>();
o.Test().AssertFailure(typeof(InvalidOperationException));
}
public void MoveNext_Crash()
{
SingleSource.Error <int>(new InvalidOperationException())
.FlatMap(v => new FailingEnumerable <int>(false, true, false))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.FlatMap(v => Enumerable.Range(v, 5))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Basic()
{
SingleSource.Error <int>(new InvalidOperationException())
.Test()
.AssertSubscribed()
.AssertFailure(typeof(InvalidOperationException));
}
public void Fallback_Error()
{
SingleSource.Error <int>(new InvalidOperationException("main"))
.OnErrorResumeNext(SingleSource.Error <int>(new InvalidOperationException("fallback")))
.Test()
.AssertFailure(typeof(InvalidOperationException))
.AssertError(typeof(InvalidOperationException), "fallback");
}
public void Time_Error()
{
SingleSource.Error <int>(new InvalidOperationException())
.DelaySubscription(TimeSpan.FromMilliseconds(100), NewThreadScheduler.Default)
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertFailure(typeof(InvalidOperationException));
}
public void Other_Delay_Error()
{
SingleSource.Error <int>(new NullReferenceException())
.DelaySubscription(SingleSource.Error <int>(new InvalidOperationException()))
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertFailure(typeof(InvalidOperationException));
}
public IDisposable Subscribe(IObserver <T> observer)
{
var en = default(IEnumerator <ISingleSource <T> >);
try
{
en = RequireNonNullRef(sources.GetEnumerator(), "The GetEnumerator returned a null IEnumerator");
}
catch (Exception ex)
{
observer.OnError(ex);
return(DisposableHelper.EMPTY);
}
if (maxConcurrency == int.MaxValue)
{
var parent = new SingleConcatEagerAllCoordinator <T>(observer, delayErrors);
for (; ;)
{
var b = false;
var src = default(ISingleSource <T>);
try
{
b = en.MoveNext();
if (!b)
{
break;
}
src = en.Current;
}
catch (Exception ex)
{
parent.SubscribeTo(SingleSource.Error <T>(ex));
break;
}
if (!parent.SubscribeTo(src))
{
break;
}
}
en.Dispose();
parent.Done();
return(parent);
}
else
{
var parent = new ConcatEagerLimitedCoordinator(observer, en, maxConcurrency, delayErrors);
parent.Drain();
return(parent);
}
}
public void Error()
{
var count = 0;
SingleSource.Error <int>(new InvalidOperationException())
.Subscribe(v => { count = v; }, e => { count = 2; });
Assert.AreEqual(2, count);
}
public void Array_Max_Error()
{
SingleSource.Merge(
SingleSource.Error <int>(new InvalidOperationException()),
SingleSource.Just(1)
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Observer_Error()
{
var to = new TestObserver <int>();
SingleSource.Error <int>(new InvalidOperationException())
.BlockingSubscribe(to);
to.AssertFailure(typeof(InvalidOperationException));
}
public void Normal_Error()
{
var to = new TestObserver <int>();
SingleSource.Error <int>(new InvalidOperationException())
.SubscribeSafe(to);
to.AssertSubscribed()
.AssertFailure(typeof(InvalidOperationException));
}
public void Array_Max_Error_Delayed()
{
SingleSource.Merge(true,
SingleSource.Just(1),
SingleSource.Error <int>(new InvalidOperationException()),
SingleSource.Just(2)
)
.Test()
.AssertFailure(typeof(InvalidOperationException), 1, 2);
}
public void Error_Cleanup_Crash_Non_Eager()
{
SingleSource.Using(() => 1,
v => SingleSource.Error <int>(new NotImplementedException()),
v => { throw new InvalidOperationException(); },
false
)
.Test()
.AssertFailure(typeof(NotImplementedException));
}
public void Handler_Crash()
{
SingleSource.Error <int>(new InvalidOperationException("main"))
.OnErrorResumeNext(e => { throw new InvalidOperationException("fallback"); })
.Test()
.AssertFailure(typeof(AggregateException))
.AssertCompositeErrorCount(2)
.AssertCompositeError(0, typeof(InvalidOperationException), "main")
.AssertCompositeError(1, typeof(InvalidOperationException), "fallback");
}
public void OnError_Basic()
{
var count = 0;
SingleSource.Error <int>(new InvalidOperationException())
.DoOnError(e => count++)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(1, count);
}
