public void Timeout_Fallback_Error()
{
var ts = new TestScheduler();
var us = new SingleSubject <int>();
var count = 0;
var fb = SingleSource.FromFunc <int>(() =>
{
++count;
throw new InvalidOperationException();
});
var to = us
.Timeout(TimeSpan.FromSeconds(1), ts, fb)
.Test();
to.AssertEmpty();
ts.AdvanceTimeBy(100);
Assert.True(us.HasObserver());
ts.AdvanceTimeBy(900);
Assert.False(us.HasObserver());
to.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(1, count);
}
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 Timeout_Fallback_Success()
{
var ts = new TestScheduler();
var us = new SingleSubject <int>();
var count = 0;
var fb = SingleSource.FromFunc <int>(() => ++ count);
var to = us
.Timeout(TimeSpan.FromSeconds(1), ts, fb)
.Test();
to.AssertEmpty();
ts.AdvanceTimeBy(100);
Assert.True(us.HasObserver());
ts.AdvanceTimeBy(900);
Assert.False(us.HasObserver());
to.AssertResult(1);
Assert.AreEqual(1, count);
}
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 Action_Just_Ignored()
{
var count = 0;
SingleSource.FromFunc(() => ++ count)
.BlockingSubscribe();
Assert.AreEqual(1, count);
}
public void Dispose_Upfront()
{
var count = 0;
SingleSource.FromFunc(() => ++ count)
.Test(true)
.AssertEmpty();
Assert.AreEqual(0, count);
}
public void Basic()
{
var count = 0;
SingleSource.FromFunc(() => ++ count)
.RetryWhen(v => v)
.Test()
.AssertResult(1);
Assert.AreEqual(1, count);
}
public void Error_Fallback_Success()
{
var count = 0;
var fb = SingleSource.FromFunc(() => ++ count);
SingleSource.Error <int>(new InvalidOperationException())
.OnErrorResumeNext(fb)
.Test()
.AssertResult(1);
Assert.AreEqual(1, count);
}
public void Handler_Success()
{
var count = 0;
var fb = SingleSource.FromFunc <int>(() => count++);
SingleSource.Just(1)
.OnErrorResumeNext(e => fb)
.Test()
.AssertResult(1);
Assert.AreEqual(0, count);
}
public void Handler_Error()
{
var count = 0;
var fb = SingleSource.FromFunc <int>(() => count++);
SingleSource.Error <int>(new InvalidOperationException())
.OnErrorResumeNext(e => fb)
.Test()
.AssertResult(0);
Assert.AreEqual(1, count);
}
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 Error_Fallback()
{
var count = 0;
var fb = SingleSource.FromFunc <int>(() => count++);
SingleSource.Error <int>(new InvalidOperationException())
.Timeout(TimeSpan.FromMinutes(1), NewThreadScheduler.Default, fb)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(0, count);
}
public void Dispose_During_Error()
{
var to = new TestObserver <int>();
SingleSource.FromFunc <int>(() => {
to.Dispose();
throw new InvalidOperationException();
})
.SubscribeWith(to)
.AssertEmpty();
Assert.True(to.IsDisposed());
}
public void Dispose_During()
{
var to = new TestObserver <int>();
SingleSource.FromFunc(() => {
to.Dispose();
return(1);
})
.SubscribeWith(to)
.AssertEmpty();
Assert.True(to.IsDisposed());
}
public void Single_Error()
{
var count = 0;
MaybeSource.Error <int>(new InvalidOperationException())
.FlatMap(v => SingleSource.FromFunc <string>(() => {
return("" + (++count));
}))
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(0, count);
}
public void Handler_False()
{
var count = 0;
var src = SingleSource.FromFunc(() => ++ count);
var obs = src.Repeat(v => false);
obs
.Test()
.AssertResult(1);
Assert.AreEqual(1, count);
}
public void Handler_Limit()
{
var count = 0;
var src = SingleSource.FromFunc(() => ++ count);
var obs = src.Repeat(v => v < 5);
obs
.Test()
.AssertResult(1, 2, 3, 4, 5);
Assert.AreEqual(5, count);
}
public void Single_Empty()
{
var count = 0;
MaybeSource.Empty <int>()
.FlatMap(v => SingleSource.FromFunc(() => {
count++;
return(v + 1);
}))
.Test()
.AssertResult();
Assert.AreEqual(0, count);
}
public void Basic()
{
var count = 0;
SingleSource.FromFunc(() => ++ count)
.RepeatWhen(v => v)
.SubscribeOn(NewThreadScheduler.Default)
.Take(5)
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertResult(1, 2, 3, 4, 5);
Assert.True(count >= 5, $"{count}");
}
public void Array_First_Wins_Error()
{
var count = 0;
var m = SingleSource.FromFunc <int>(() => ++ count);
SingleSource.Amb(
SingleSource.Error <int>(new InvalidOperationException()),
m
)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(0, count);
}
public void Error()
{
var count = 0;
SingleSource.FromFunc <int>(() =>
{
count++;
throw new InvalidOperationException();
})
.RepeatWhen(v => v)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.AreEqual(1, count);
}
public void DisposeUpfront()
{
var name = -1;
SingleSource.FromFunc <int>(() =>
{
name = Thread.CurrentThread.ManagedThreadId;
throw new InvalidOperationException();
})
.SubscribeOn(NewThreadScheduler.Default)
.Test(true)
.AssertEmpty();
Assert.AreEqual(-1, name);
}
public void Limited_Repeat()
{
var count = 0;
SingleSource.FromFunc(() => ++ count)
.RepeatWhen(v =>
{
var idx = 0;
return(v.TakeWhile(w => ++ idx < 5));
})
.Test()
.AssertResult(1, 2, 3, 4, 5);
Assert.AreEqual(5, count);
}
public void Handler_Error()
{
var count = 0;
SingleSource.FromFunc <int>(() =>
{
if (++count < 5)
{
throw new InvalidOperationException();
}
return(count);
})
.Retry((e, i) => true)
.Test()
.AssertResult(5);
}
public void Times_Error_Limit_Fail()
{
var count = 0;
SingleSource.FromFunc <int>(() =>
{
if (++count < 5)
{
throw new InvalidOperationException();
}
return(count);
})
.Retry(3)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Times_Error_Limit()
{
var count = 0;
SingleSource.FromFunc <int>(() =>
{
if (++count < 5)
{
throw new InvalidOperationException();
}
return(count);
})
.Retry(5)
.Test()
.AssertResult(5);
}
public void Array_Max_Error_Delay()
{
var count = 0;
var src = SingleSource.FromFunc(() => ++ count);
SingleSource.ConcatEager(true,
SingleSource.Just(0),
SingleSource.Error <int>(new InvalidOperationException()),
src
)
.Test()
.AssertFailure(typeof(InvalidOperationException), 0, 1);
Assert.AreEqual(1, count);
}
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 Array_First_Wins_Success()
{
var count = 0;
var m = SingleSource.FromFunc <int>(() => ++ count);
new[]
{
SingleSource.Just(0),
m
}
.AmbAll()
.Test()
.AssertResult(0);
Assert.AreEqual(0, 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);
}
