public void Enumerable_Many()
{
var list = new List <IMaybeSource <int> >();
for (int i = 0; i < 100; i++)
{
if (i != 99)
{
list.Add(MaybeSource.Never <int>());
}
else
{
list.Add(MaybeSource.Just(1));
}
}
list
.Amb()
.Test()
.AssertResult(1);
}
public void Array_Limit_Keep_Order()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.ConcatEager(2,
ms1, ms2
)
.Test();
Assert.True(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms2.OnSuccess(2);
to.AssertEmpty();
ms1.OnSuccess(1);
to.AssertResult(1, 2);
}
public void Limit_Error_Delay()
{
for (int i = 1; i < 10; i++)
{
var count = 0;
var src = MaybeSource.FromFunc(() => ++ count);
MaybeSource.ConcatEager(
new [] {
MaybeSource.Just(0),
MaybeSource.Error <int>(new InvalidOperationException()),
src
}.ToObservable(), true, i
)
.Test()
.AssertFailure(typeof(InvalidOperationException), 0, 1);
Assert.AreEqual(1, count);
}
}
public void Crash()
{
var count = 0;
var c = MaybeSource.FromAction <int>(() =>
{
count++;
throw new InvalidOperationException();
});
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(i, count);
c.Test()
.AssertSubscribed()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(i + 1, count);
}
}
public void Enumerable_Second_Wins_Error()
{
var count = 0;
var m = MaybeSource.FromFunc <int>(() => {
count++;
throw new InvalidOperationException();
});
MaybeSource.Amb(
new List <IMaybeSource <int> >()
{
MaybeSource.Never <int>(),
m
}
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(1, count);
}
public void Array_Limit_Max_Concurrency()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.ConcatEager(1,
ms1, ms2
)
.Test();
Assert.True(ms1.HasObserver());
Assert.False(ms2.HasObserver());
ms1.OnSuccess(1);
Assert.False(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms2.OnSuccess(2);
to.AssertResult(1, 2);
}
public void Max_Error_Dispose_Second()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.ConcatEager(
new [] {
ms1, ms2
}.ToObservable()
)
.Test();
Assert.True(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms2.OnError(new InvalidOperationException());
Assert.False(ms1.HasObserver());
Assert.False(ms2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException));
}
public void Enumerable_Max_Error_Dispose_First()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.ConcatEager(
new List <IMaybeSource <int> >()
{
ms1, ms2
}
)
.Test();
Assert.True(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms1.OnError(new InvalidOperationException());
Assert.False(ms1.HasObserver());
Assert.False(ms2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException));
}
public void Limit_Keep_Order()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.ConcatEager(
new [] {
ms1, ms2
}.ToObservable(), maxConcurrency: 2
)
.Test();
Assert.True(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms2.OnSuccess(2);
to.AssertEmpty();
ms1.OnSuccess(1);
to.AssertResult(1, 2);
}
public void Error()
{
var resource = new SingleAssignmentDisposable();
var before = -1;
var after = -1;
var source = MaybeSource.Create <int>(e =>
{
e.SetResource(resource);
before = e.IsDisposed() ? 1 : 0;
e.OnError(new InvalidOperationException());
after = e.IsDisposed() ? 1 : 0;
});
source.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(0, before);
Assert.AreEqual(1, after);
Assert.True(resource.IsDisposed());
}
public void Empty()
{
var resource = new SingleAssignmentDisposable();
var before = -1;
var after = -1;
var source = MaybeSource.Create <int>(e =>
{
e.SetResource(resource);
before = e.IsDisposed() ? 1 : 0;
e.OnCompleted();
after = e.IsDisposed() ? 1 : 0;
});
source.Test()
.AssertResult();
Assert.AreEqual(0, before);
Assert.AreEqual(1, after);
Assert.True(resource.IsDisposed());
}
public void Dispose_Fallback()
{
var ts = new TestScheduler();
var us = new MaybeSubject <int>();
var to = MaybeSource.Never <int>()
.Timeout(TimeSpan.FromSeconds(1), ts, us)
.Test();
ts.AdvanceTimeBy(100);
Assert.False(us.HasObserver());
ts.AdvanceTimeBy(900);
Assert.True(us.HasObserver());
to.Dispose();
Assert.False(us.HasObserver());
to.AssertEmpty();
}
public void Enumerable_Max_Keep_Order()
{
var ms1 = new MaybeSubject <int>();
var ms2 = new MaybeSubject <int>();
var to = MaybeSource.ConcatEager(
new List <IMaybeSource <int> >()
{
ms1, ms2
}
)
.Test();
Assert.True(ms1.HasObserver());
Assert.True(ms2.HasObserver());
ms2.OnSuccess(2);
to.AssertEmpty();
ms1.OnSuccess(1);
to.AssertResult(1, 2);
}
public void Basic()
{
MaybeSource.Empty <int>()
.Test()
.AssertResult();
}
public void NoValue_Delayed_Basic_Timeout_CancellationTokenSource()
{
MaybeSource.Empty <int>()
.Delay(TimeSpan.FromMilliseconds(100), NewThreadScheduler.Default)
.Wait(5000, cts: new CancellationTokenSource());
}
public void NoValue_Delayed_Basic_Timeout()
{
MaybeSource.Empty <int>()
.Delay(TimeSpan.FromMilliseconds(100), NewThreadScheduler.Default)
.Wait(5000);
}
public void Error()
{
MaybeSource.FromFunc <int>(() => { throw new InvalidOperationException(); })
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Maybe_Dispose()
{
TestHelper.VerifyDisposeSingle <int, int>(m => m.FlatMap(v => MaybeSource.Just(2)));
}
public void Maybes_Fallback_Dispose()
{
TestHelper.VerifyDisposeMaybe <int, int>(m =>
MaybeSource.Empty <int>().SwitchIfEmpty(MaybeSource.Empty <int>(), m)
);
}
public void Enumerable_MoveNext_Crash()
{
MaybeSource.Concat(new FailingEnumerable <IMaybeSource <int> >(false, true, false))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Maybe_Dispose_Inner()
{
TestHelper.VerifyDisposeMaybe <int, int>(m => MaybeSource.Just(1).FlatMap(v => m));
}
public void Enumerable_GetEnumerator_Crash()
{
MaybeSource.Amb(new FailingEnumerable <IMaybeSource <int> >(true, false, false))
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Maybes_Dispose()
{
TestHelper.VerifyDisposeMaybe <int, int>(m =>
m.SwitchIfEmpty(MaybeSource.Just(2))
);
}
public void NoValue_Basic()
{
MaybeSource.Empty <int>()
.Wait();
}
public void Single_Dispose_Fallback()
{
TestHelper.VerifyDisposeSingle <int, int>(m => MaybeSource.Empty <int>().SwitchIfEmpty(m));
}
public void NoValue_Success()
{
MaybeSource.Just(1)
.Wait();
}
public void Basic()
{
MaybeSource.FromFunc(() => 1)
.Test()
.AssertResult(1);
}
public void NoValue_Basic_Timeout()
{
MaybeSource.Empty <int>()
.Wait(5000);
}
public void Action_Block_Error_Ignored()
{
MaybeSource.Error <int>(new InvalidOperationException())
.BlockingSubscribe();
}
public void NoValue_Basic_Timeout_CancellationTokenSource()
{
MaybeSource.Empty <int>()
.Wait(5000, cts: new CancellationTokenSource());
}
