public void Normal()
{
Flowable.Range(1, 10).Debounce(TimeSpan.FromMinutes(1))
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertResult(10);
}
public void Normal()
{
Flowable.FromArray(1, 2, 2, 3, 3, 4, 4, 5, 5, 6)
.DistinctUntilChanged()
.Test()
.AssertResult(1, 2, 3, 4, 5, 6);
}
internal void Start()
{
if (Interlocked.CompareExchange(ref state, STATE_STARTED, STATE_SHUTDOWN) == STATE_SHUTDOWN)
{
Volatile.Write(ref runner, new BlockingQueueConsumer(Flowable.BufferSize(), name));
}
}
public void Rebatch()
{
Flowable.Concat(Flowable.Range(1, 3), Flowable.Range(4, 3))
.RebatchRequests(1)
.Test()
.AssertResult(1, 2, 3, 4, 5, 6);
}
public void Take()
{
Flowable.Concat(Flowable.Range(1, 3), Flowable.Range(4, 3))
.Take(4)
.Test()
.AssertResult(1, 2, 3, 4);
}
public void SyncReduceAll()
{
for (int j = 0; j <= 100; j++)
{
for (int i = 1; i < 33; i++)
{
long sum = (1 + j) * j / 2;
var ts = Flowable.Range(1, j)
.Parallel(i)
.Map(v => (long)v)
.ReduceAll((a, b) => a + b)
.Test()
.WithTag("len = " + j + ", parallel = " + i)
;
if (j == 0)
{
ts.AssertResult();
}
else
{
ts.AssertResult(sum);
}
}
}
}
public void Normal3()
{
Flowable.Range(1, 5).Map(v => 0).Reduce((a, b) => a + b)
.BlockingFirst(out int sum);
Assert.AreEqual(0, sum);
}
public void Normal()
{
Flowable.Range(1, 10)
.TakeWhile(v => v <= 5)
.Test()
.AssertResult(1, 2, 3, 4, 5);
}
public void NormalAll()
{
Flowable.Range(1, 5)
.TakeWhile(v => true)
.Test()
.AssertResult(1, 2, 3, 4, 5);
}
public void Fallback()
{
Flowable.Never <int>().Timeout(TimeSpan.FromMilliseconds(100), Flowable.Range(1, 5))
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertResult(1, 2, 3, 4, 5);
}
public void AsyncHidden2()
{
var j = 2294;
var i = Environment.ProcessorCount;
var completions = 0;
try
{
Flowable.Range(1, j)
.Hide()
.Parallel(i)
.DoOnComplete(() => Interlocked.Increment(ref completions))
.RunOn(Executors.Computation)
.Sequential()
.Test()
.WithTag("len=" + j + ", i=" + i)
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertValueCount(j)
.AssertValueSet(new HashSet <int>(Enumerable.Range(1, j)))
.AssertNoError()
.AssertComplete();
}
finally
{
Assert.AreEqual(i, Volatile.Read(ref completions));
}
}
public override IPublisher <int> CreatePublisher(long elements)
{
return(Flowable.Range(1, (int)elements)
.FlatMap(v => Flowable.Range(v, v == elements ? 1 : 2))
.DistinctUntilChanged()
.Filter(v => true));
}
public void Normal()
{
Flowable.Range(1, 10)
.TakeUntil(v => v == 5)
.Test()
.AssertResult(1, 2, 3, 4, 5);
}
public override IPublisher <int> CreatePublisher(long elements)
{
return(Flowable.Range(1, (int)elements)
.Parallel()
.RunOn(Executors.Computation)
.Sequential());
}
public void PublishHide()
{
Flowable.Range(1, 5).Hide()
.Publish(f => f.Take(3).ConcatWith(f.TakeLast(3)))
.Test()
.AssertResult(1, 2, 3, 4, 5);
}
public void Empty()
{
Flowable.Empty <int>()
.DefaultIfEmpty(1)
.Test()
.AssertResult(1);
}
public void ReplayHide()
{
Flowable.Range(1, 5)
.Replay(f => f.Take(3).ConcatWith(f.TakeLast(3)))
.Test()
.AssertResult(1, 2, 3, 3, 4, 5);
}
public void NormalConditional()
{
Flowable.Concat(Flowable.Range(1, 3), Flowable.Range(4, 3))
.Filter(v => true)
.Test()
.AssertResult(1, 2, 3, 4, 5, 6);
}
public void AsyncReduceAll()
{
for (int j = 0; j <= 100; j++)
{
for (int i = 1; i < 33; i++)
{
long sum = (1 + j) * j / 2;
var ts = Flowable.Range(1, j)
.Parallel(i)
.RunOn(Executors.Computation)
.Map(v => (long)v)
.ReduceAll((a, b) => a + b)
.Test()
.AwaitDone(TimeSpan.FromSeconds(5))
.WithTag("len = " + j + ", parallel = " + i)
;
if (j == 0)
{
ts.AssertResult();
}
else
{
ts.AssertResult(sum);
}
}
}
}
public void Shared()
{
IExecutorService[] execs = { Executors.Single, Executors.Computation, Executors.IO };
foreach (var exec in execs)
{
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
Flowable.Just(1).SubscribeOn(exec)
.Test()
.WithTag("SubscribeOn round " + i + "/" + j + " - " + exec.GetType().Name)
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertResult(1);
Flowable.Just(1).Delay(TimeSpan.FromMilliseconds(10))
.Test()
.WithTag("Delay round " + i + "/" + j + " - " + exec.GetType().Name)
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertResult(1);
Flowable.Interval(TimeSpan.FromMilliseconds(10))
.Take(5)
.Test()
.WithTag("Interval round " + i + "/" + j + " - " + exec.GetType().Name)
.AwaitDone(TimeSpan.FromSeconds(5))
.AssertResult(0L, 1L, 2L, 3L, 4L);
}
}
}
}
public override IPublisher <int> CreatePublisher(long elements)
{
return(Flowable.Range(1, (int)elements)
.FlatMap(v => v == 1 ? Flowable.Just(v) : Flowable.FromArray(v, v - 1))
.Distinct()
.Filter(v => true));
}
public override IPublisher <int> CreatePublisher(long elements)
{
return(Flowable.Range(1, (int)elements)
.Hide()
.Parallel()
.Sequential());
}
public void Normal()
{
Flowable.Range(1, 10)
.SkipLast(5)
.Test()
.AssertResult(1, 2, 3, 4, 5);
}
public void Range()
{
Flowable.Range(1, 1000)
.SubscribeWith(new UnicastProcessor <int>())
.Test()
.AssertResult(Enumerable.Range(1, 1000).ToArray());
}
public void Error()
{
Flowable.Error <int>(new Exception())
.SubscribeWith(new UnicastProcessor <int>())
.Test()
.AssertFailure(typeof(Exception));
}
public void Normal()
{
Flowable.Range(1, 10)
.TakeLast(5)
.Test()
.AssertResult(6, 7, 8, 9, 10);
}
public void AsyncMerge()
{
var maxConcurrency = 2;
var prefetch = Flowable.BufferSize();
var backpressureStrategy = BackpressureStrategy.BUFFER;
var flowable = Flowable.Range(0, 5).FlatMap(x =>
{
return(Flowable.Create <int>(e =>
{
// Thread to emulate some asynchronous action
new Thread(() =>
{
for (var i = 0; i < 10; ++i)
{
Thread.Sleep(100);
e.OnNext(x * i);
}
e.OnComplete();
}).Start();
}, backpressureStrategy));
}, maxConcurrency, prefetch);
var v = flowable
.Test()
.AwaitDone(TimeSpan.FromSeconds(6))
.AssertNoError()
.AssertComplete()
.Values
;
Assert.AreEqual(50, v.Count);
}
public void Simple()
{
Flowable.Range(1, 5)
.FlatMap(v => Flowable.Range(v, 2))
.Test()
.AssertResult(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
}
public void AllGroupLongHidden()
{
Flowable.Range(1, 1000).GroupBy(v => v).FlatMap(v => v.Hide(), int.MaxValue)
.Test()
.AssertValueCount(1000)
.AssertNoError()
.AssertComplete();
}
public void OneGroupLong()
{
Flowable.Range(1, 1000).GroupBy(v => 1).FlatMap(v => v)
.Test()
.AssertValueCount(1000)
.AssertNoError()
.AssertComplete();
}
