public void Success_Fallback()
{
var count = 0;
var fb = SingleSource.FromFunc <int>(() => count++);
SingleSource.Just(1)
.Timeout(TimeSpan.FromMinutes(1), NewThreadScheduler.Default, fb)
.Test()
.AssertResult(1);
Assert.AreEqual(0, count);
}
public void Array_Max_Basic()
{
new []
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3)
}
.ConcatEagerAll()
.Test()
.AssertResult(1, 2, 3);
}
public void Finally_Basic_Twice()
{
var count = 0;
SingleSource.Just(1)
.DoFinally(() => count++)
.DoFinally(() => count++)
.Test()
.AssertResult(1);
Assert.AreEqual(2, count);
}
public void Success()
{
var name = "";
SingleSource.Just(1)
.DoOnDispose(() => name = Thread.CurrentThread.Name)
.UnsubscribeOn(NewThreadScheduler.Default)
.Test()
.AssertResult(1);
Assert.AreEqual("", name);
}
public void Enumerable_Max_Error()
{
SingleSource.Merge(
new List <ISingleSource <int> >()
{
SingleSource.Error <int>(new InvalidOperationException()),
SingleSource.Just(1)
}
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void OnSuccess_Basic_Twice()
{
var count = 0;
SingleSource.Just(1)
.DoOnSuccess(v => count++)
.DoOnSuccess(v => count++)
.Test()
.AssertResult(1);
Assert.AreEqual(2, count);
}
public void Array_Max_Basic_DelayError()
{
new[]
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3),
}
.MergeAll(true)
.Test()
.AssertResult(1, 2, 3);
}
public void Enumerable_Max_Basic_DelayError()
{
new List <ISingleSource <int> >()
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3),
}
.Merge(true)
.Test()
.AssertResult(1, 2, 3);
}
public void AferTerminate_Basic_Twice()
{
var count = 0;
SingleSource.Just(1)
.DoAfterTerminate(() => count++)
.DoAfterTerminate(() => count++)
.Test()
.AssertResult(1);
Assert.AreEqual(2, count);
}
public void Array_Limited_Error()
{
for (int i = 1; i < 10; i++)
{
SingleSource.Merge(i,
SingleSource.Error <int>(new InvalidOperationException()),
SingleSource.Just(1)
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
}
public void Enumerable_Max_Basic()
{
new List <ISingleSource <int> >()
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3)
}
.ConcatEager()
.Test()
.AssertResult(1, 2, 3);
}
public void Max_Basic()
{
new []
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3)
}.ToObservable()
.ConcatEager()
.Test()
.AssertResult(1, 2, 3);
}
public void Limit_Dispose_Main()
{
var s = new Subject <int>();
var to = s.ConcatMapEager(v => SingleSource.Just(v), maxConcurrency: 1)
.Test();
Assert.True(s.HasObservers);
to.Dispose();
Assert.False(s.HasObservers);
}
public void Array_Error_Last()
{
new[]
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3),
SingleSource.Error <int>(new InvalidOperationException())
}
.ConcatAll()
.Test()
.AssertFailure(typeof(InvalidOperationException), 1, 2, 3);
}
public void Max_Eager_Inner_Error()
{
Observable.Range(1, 5)
.FlatMap(v => {
if (v == 3)
{
return(SingleSource.Error <int>(new InvalidOperationException()));
}
return(SingleSource.Just(v + 1));
})
.Test()
.AssertFailure(typeof(InvalidOperationException), 2, 3);
}
public void Enumerable_Error_Last_Delay()
{
new List <ISingleSource <int> >()
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3),
SingleSource.Error <int>(new InvalidOperationException())
}
.Concat(true)
.Test()
.AssertFailure(typeof(InvalidOperationException), 1, 2, 3);
}
public void Maybe_Inner_Empty()
{
var count = 0;
SingleSource.Just(1)
.FlatMap(v => MaybeSource.FromAction <string>(() => {
count++;
}))
.Test()
.AssertResult();
Assert.AreEqual(1, count);
}
public void OnAfterSuccess_Basic()
{
var count = -1;
var to = new TestObserver <int>();
SingleSource.Just(1)
.DoAfterSuccess(v => count = to.ItemCount)
.SubscribeWith(to)
.AssertResult(1);
Assert.AreEqual(1, count);
}
public void Delayed_Inner_Error()
{
Observable.Range(1, 5)
.SwitchMap(v => {
if (v == 3)
{
return(SingleSource.Error <int>(new InvalidOperationException()));
}
return(SingleSource.Just(v + 1));
}, true)
.Test()
.AssertFailure(typeof(InvalidOperationException), 2, 3, 5, 6);
}
public void Limit_Dispose_Main_DelayError()
{
var s = new Subject <int>();
var to = s.ConcatMapEager(v => SingleSource.Just(v), true, 1)
.Test();
Assert.True(s.HasObservers);
to.Dispose();
Assert.False(s.HasObservers);
}
public void Array_Limit_Basic_Delay()
{
for (int i = 1; i < 10; i++)
{
SingleSource.ConcatEager <int>(true, i,
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3)
)
.Test()
.WithTag($"{i}")
.AssertResult(1, 2, 3);
}
}
public void Single_Dispose_Main()
{
var cs = new CompletableSubject();
var to = cs
.AndThen(SingleSource.Just(1))
.Test();
Assert.True(cs.HasObserver());
to.Dispose();
Assert.False(cs.HasObserver());
}
public void Success()
{
var name = -1;
SingleSource.Just(1)
.ObserveOn(NewThreadScheduler.Default)
.DoOnSuccess(v => name = Thread.CurrentThread.ManagedThreadId)
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertResult(1);
Assert.AreNotEqual(-1, name);
Assert.AreNotEqual(Thread.CurrentThread.ManagedThreadId, name);
}
public void Array_Limited_Null_Source()
{
for (int i = 1; i < 10; i++)
{
SingleSource.Merge(i,
SingleSource.Just(1),
null,
SingleSource.Just(2)
)
.Test()
.AssertNotCompleted()
.AssertError(typeof(NullReferenceException));
}
}
public void Enumerable_Max_Null_Source()
{
SingleSource.Merge(
new List <ISingleSource <int> >()
{
SingleSource.Just(1),
null,
SingleSource.Just(2)
}
)
.Test()
.AssertNotCompleted()
.AssertError(typeof(NullReferenceException));
}
public void Max_Mapper_Crash_Delayed()
{
Observable.Range(1, 5)
.ConcatMapEager <int, int>(v =>
{
if (v == 3)
{
throw new InvalidOperationException();
}
return(SingleSource.Just(v));
}, true)
.Test()
.AssertFailure(typeof(InvalidOperationException), 1, 2);
}
public void OnDispose_Success()
{
var count = 0;
SingleSource.Just(1)
.DoOnDispose(() =>
{
count++;
})
.Test()
.AssertResult(1);
;
Assert.AreEqual(0, count);
}
public void Enumerable_Limited_Basic_DelayError()
{
for (int i = 1; i < 10; i++)
{
new List <ISingleSource <int> >()
{
SingleSource.Just(1),
SingleSource.Just(2),
SingleSource.Just(3),
}
.Merge(true, i)
.Test()
.AssertResult(1, 2, 3);
}
}
public void Enumerable_Limited_Error()
{
for (int i = 1; i < 10; i++)
{
SingleSource.Merge(
new List <ISingleSource <int> >()
{
SingleSource.Error <int>(new InvalidOperationException()),
SingleSource.Just(1)
}, maxConcurrency: i
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
}
public void Max_Mapper_Crash()
{
Observable.Range(1, 5)
.ConcatMapEager <int, int>(v =>
{
if (v == 3)
{
throw new InvalidOperationException();
}
return(SingleSource.Just(v));
})
.Test()
.AssertNotCompleted()
.AssertError(typeof(InvalidOperationException));
}
