public void ThenMany_Normal()
{
Flux.Range(1, 10)
.ThenMany(Flux.Range(11, 10))
.Test()
.AssertResult(11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
}
public void Single_Many()
{
Flux.Range(1, 10).Single().Test()
.AssertNoValues()
.AssertError(e => e is IndexOutOfRangeException)
.AssertNotComplete();
}
public void SkipWhile_Normal_Fused()
{
Flux.Range(1, 10).SkipWhile(v => v < 6)
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.SYNC)
.AssertResult(6, 7, 8, 9, 10);
}
public void SwitchIfEmpty_Conditional_Empty()
{
Flux.Empty <int>().SwitchIfEmpty(Flux.Range(1, 10))
.Filter(v => true)
.Test()
.AssertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
public void TakeWhile_Normal_Fused()
{
Flux.Range(1, 10).TakeWhile(v => v <= 5)
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.SYNC)
.AssertResult(1, 2, 3, 4, 5);
}
public void SwitchIfEmpty_Conditional_NonEmpty()
{
Flux.Range(11, 10).SwitchIfEmpty(Flux.Range(1, 10))
.Filter(v => true)
.Test()
.AssertResult(11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
}
public void TakeUntilPredicate_Normal_Fused()
{
Flux.Range(1, 10).TakeUntil(v => v == 5)
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.SYNC)
.AssertResult(1, 2, 3, 4, 5);
}
public void Parallel_Sorted_Async()
{
for (int j = 1; j <= Environment.ProcessorCount; j++)
{
for (int i = 1; i <= 100000; i *= 10)
{
var ts = Flux.Range(1, i)
.Map(v => i - v + 1)
.Parallel(j, true)
.RunOn(DefaultScheduler.Instance)
.Sorted()
.Test();
ts.AwaitTerminalEvent(TimeSpan.FromSeconds(20));
ts.AssertValueCount(i)
.AssertNoError()
.AssertComplete();
for (int k = 1; k <= i; k++)
{
Assert.AreEqual(k, ts.Values[k - 1]);
}
}
}
}
public void Buffer_Skip()
{
Flux.Range(1, 5).Buffer(2, 3).Test().AssertResult(
new List <int>(new[] { 1, 2 }),
new List <int>(new[] { 4, 5 })
);
}
public void PublishProcessor_Normal()
{
PublishProcessor <int> pp = new PublishProcessor <int>();
var ts1 = pp.Test(0);
var ts2 = pp.Test(0);
ts1.AssertNoEvents();
ts2.AssertNoValues();
Flux.Range(1, 10).Subscribe(pp);
ts1.AssertNoEvents();
ts2.AssertNoValues();
ts1.Request(1);
ts1.AssertNoEvents();
ts2.AssertNoValues();
ts2.Request(10);
ts1.AssertValues(1);
ts2.AssertValues(1);
ts1.Request(9);
ts1.AssertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
ts2.AssertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
public void TakeLast_Single_Fused()
{
Flux.Range(1, 10).TakeLast(1)
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.ASYNC)
.AssertResult(10);
}
public void OnBackpressureBuffer_Fused()
{
Flux.Range(1, 10).OnBackpressureBuffer()
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.ASYNC)
.AssertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
public void OnErrorResumeWith_Error()
{
Flux.Range(1, 5)
.ConcatWith(Flux.Error <int>(new Exception()))
.OnErrorResumeWith(e => Flux.Range(6, 5))
.Test().AssertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
public void Then_EmptyVoid_Fused()
{
Flux.Range(1, 10).Then(Mono.Empty <Void>())
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.ASYNC)
.AssertResult();
}
public void Using_Normal_Fused()
{
Flux.Using(() => 1, s => Flux.Range(1, 5), s => { })
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.SYNC)
.AssertResult(1, 2, 3, 4, 5);
}
public void Parallel_Filter()
{
Flux.Range(1, 10).Parallel(2)
.Filter(v => (v & 1) != 0)
.Sequential()
.Test()
.AssertResult(1, 3, 5, 7, 9);
}
public void Parallel_Normal_Fused_Long()
{
Flux.Range(1, 10000).Parallel(2)
.Sequential().Test()
.AssertValueCount(10000)
.AssertNoError()
.AssertComplete();
}
public void Parallel_Map()
{
Flux.Range(1, 10).Parallel(2)
.Map(v => v * 2)
.Sequential()
.Test()
.AssertResult(2, 4, 6, 8, 10, 12, 14, 16, 18, 20);
}
public void ThenMany_Conditional()
{
Flux.Range(1, 10)
.ThenMany(Flux.Range(11, 10))
.Filter(v => true)
.Test()
.AssertResult(11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
}
public void Buffer_Exact()
{
Flux.Range(1, 5).Buffer(2).Test().AssertResult(
new List <int>(new[] { 1, 2 }),
new List <int>(new[] { 3, 4 }),
new List <int>(new[] { 5 })
);
}
public void Process_DirectProcessor()
{
var co = Flux.Range(1, 10).Process(() => new DirectProcessor <int>(), o => o.Map(v => v + 1));
var ts = co.Test();
co.Connect();
ts.AssertResult(2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
}
public void Take_Fused_Exact_Boundary_Backpressure()
{
var ts = Flux.Range(1, 2)
.Take(1)
.PublishOn(ImmediateScheduler.Instance)
.Test(1, FuseableHelper.ANY);
ts.AssertResult(1);
}
public void PublishOn_Normal_FusedIn()
{
Flux.Range(1, 1000000)
.PublishOn(DefaultScheduler.Instance)
.Test()
.AwaitTerminalEvent()
.AssertValueCount(1000000)
.AssertNoError()
.AssertComplete();
}
public void ConcatMap_End_Error_Fused()
{
var ts = Flux.Range(1, 3)
.ConcatMap(v => v != 2 ? Flux.Range(1, 3) : Flux.Error <int>(new Exception("Forced failure")), ConcatErrorMode.End)
.Test();
ts.AssertValues(1, 2, 3, 1, 2, 3)
.AssertError(e => e.Message.Equals("Forced failure"))
.AssertNotComplete();
}
public void Buffer_Overlap()
{
Flux.Range(1, 5).Buffer(2, 1).Test().AssertResult(
new List <int>(new[] { 1, 2 }),
new List <int>(new[] { 2, 3 }),
new List <int>(new[] { 3, 4 }),
new List <int>(new[] { 4, 5 }),
new List <int>(new[] { 5 })
);
}
public void ConcatMap_Conditional_Boundary_Error_Fused()
{
var ts = Flux.Range(1, 3)
.ConcatMap(v => v != 2 ? Flux.Range(1, 3) : Flux.Error <int>(new Exception("Forced failure")), ConcatErrorMode.Boundary)
.Filter(v => true).Test();
ts.AssertValues(1, 2, 3)
.AssertError(e => e.Message.Equals("Forced failure"))
.AssertNotComplete();
}
public void GroupBy_Normal()
{
Flux.Range(1, 10).GroupBy(k => k & 1)
.FlatMap(g => g.CollectList())
.Test()
.AssertResult(
new List <int>(new [] { 1, 3, 5, 7, 9 }),
new List <int>(new[] { 2, 4, 6, 8, 10 })
);
}
public void Parallel_Ordered_Join()
{
for (int j = 1; j <= 32; j++)
{
Flux.Range(1, 10)
.Parallel(j, true)
.Sequential()
.Test()
.AssertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
}
public void GroupBy_2_of_3_Groups()
{
Flux.Range(1, 10).GroupBy(k => k % 3)
.Take(2)
.FlatMap(g => g.CollectList())
.Test()
.AssertResult(
new List <int>(new[] { 1, 4, 7, 10 }),
new List <int>(new[] { 2, 5, 8 })
);
}
public void SwitchMap_Normal_Fused()
{
var dp = new DirectProcessor <int>();
var ts = dp.SwitchMap(v => Flux.Range(v, 2))
.Test();
dp.OnNext(1, 2, 3);
dp.OnComplete();
ts.AssertResult(1, 2, 2, 3, 3, 4);
}
