public void Basic()
{
SingleSource.Never <int>()
.Test()
.AssertSubscribed()
.AssertEmpty();
}
public void Dispose_Cleanup_Crash()
{
SingleSource.Using(() => 1,
v => SingleSource.Never <int>(),
v => { throw new InvalidOperationException(); },
false
)
.Test()
.Cancel()
.AssertEmpty();
}
public void OnDispose_Basic()
{
var count = 0;
SingleSource.Never <int>()
.DoOnDispose(() => count++)
.Test(true)
.AssertEmpty();
Assert.AreEqual(1, count);
}
public void Resource_Supplier_Crash()
{
var cleanup = -1;
var run = 0;
SingleSource.Using <int, int>(() => { throw new InvalidOperationException(); },
v => { run = 1; return(SingleSource.Never <int>()); },
v => cleanup = run
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(-1, cleanup);
Assert.AreEqual(0, run);
}
public void Enumerable_Null_Entry()
{
var src = SingleSource.Never <int>();
new List <ISingleSource <int> >()
{
src,
src,
null,
src,
src
}
.Amb()
.Test()
.AssertFailure(typeof(NullReferenceException));
}
public void Array_Null_Entry()
{
var src = SingleSource.Never <int>();
new[]
{
src,
src,
null,
src,
src
}
.Amb()
.Test()
.AssertFailure(typeof(NullReferenceException));
}
public void OnDispose_Crash()
{
var count = 0;
SingleSource.Never <int>()
.DoOnDispose(() =>
{
count++;
throw new InvalidOperationException();
})
.Test(true)
.AssertEmpty();
;
Assert.AreEqual(1, count);
}
public void Dispose()
{
var cleanup = -1;
var run = 0;
SingleSource.Using(() => 1,
v => SingleSource.Never <int>(),
v => cleanup = run
)
.DoOnSuccess(v => run = 1)
.Test()
.Dispose();
Assert.AreEqual(0, cleanup);
Assert.AreEqual(0, run);
}
public void Array_Second_Wins_Success()
{
var count = 0;
var m = SingleSource.FromFunc <int>(() => ++ count);
new[]
{
SingleSource.Never <int>(),
m
}
.AmbAll()
.Test()
.AssertResult(1);
Assert.AreEqual(1, count);
}
public void Enumerable_Second_Wins_Success()
{
var count = 0;
var m = SingleSource.FromFunc <int>(() => ++ count);
new List <ISingleSource <int> >()
{
SingleSource.Never <int>(),
m
}
.Amb()
.Test()
.AssertResult(1);
Assert.AreEqual(1, count);
}
public void Array_Second_Wins_Error()
{
var count = 0;
var m = SingleSource.FromFunc <int>(() => {
count++;
throw new InvalidOperationException();
});
SingleSource.Amb(
SingleSource.Never <int>(),
m
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(1, count);
}
public void Dispose()
{
var name = "";
var cdl = new CountdownEvent(1);
SingleSource.Never <int>()
.DoOnDispose(() =>
{
name = Thread.CurrentThread.Name;
cdl.Signal();
})
.UnsubscribeOn(NewThreadScheduler.Default)
.Test()
.Dispose();
Assert.True(cdl.Wait(5000));
Assert.AreNotEqual("", name);
Assert.AreNotEqual(Thread.CurrentThread.Name, name);
}
public void Enumerable_Many()
{
var list = new List <ISingleSource <int> >();
for (int i = 0; i < 100; i++)
{
if (i != 99)
{
list.Add(SingleSource.Never <int>());
}
else
{
list.Add(SingleSource.Just(1));
}
}
list
.Amb()
.Test()
.AssertResult(1);
}
public void Dispose_Fallback()
{
var ts = new TestScheduler();
var us = new SingleSubject <int>();
var to = SingleSource.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();
}
