public void Normal()
{
var dp1 = new DirectProcessor <int>();
var dp2 = new DirectProcessor <int>();
var ts = dp1.Window(dp2).Merge().Test();
ts.AssertEmpty();
dp1.OnNext(1);
dp1.OnNext(2);
dp2.OnNext(100);
ts.AssertValues(1, 2)
.AssertNoError()
.AssertNotComplete();
dp2.OnNext(200);
ts.AssertValues(1, 2)
.AssertNoError()
.AssertNotComplete();
dp1.OnNext(3);
dp1.OnNext(4);
dp1.OnNext(5);
dp1.OnComplete();
Assert.IsFalse(dp2.HasSubscribers);
ts.AssertResult(1, 2, 3, 4, 5);
}
public void Lockstep()
{
var dp1 = new DirectProcessor <int>();
var dp2 = new DirectProcessor <int>();
TestSubscriber <int> ts = dp1.Sample(dp2).Test();
ts.AssertEmpty();
dp1.OnNext(1);
dp1.OnNext(2);
dp2.OnNext(100);
ts.AssertValues(2);
dp2.OnNext(100);
ts.AssertValues(2);
dp1.OnNext(3);
dp1.OnNext(4);
dp2.OnNext(200);
ts.AssertValues(2, 4);
dp2.OnComplete();
ts.AssertResult(2, 4);
Assert.IsFalse(dp1.HasSubscribers);
Assert.IsFalse(dp2.HasSubscribers);
}
public void BufferBoundary_Normal()
{
var other = new DirectProcessor <int>();
var main = new DirectProcessor <int>();
var ts = main.Buffer(other).Test();
main.OnNext(1, 2, 3);
other.OnNext(1);
main.OnNext(4, 5);
other.OnNext(2, 3);
main.OnNext(6);
main.OnComplete();
Assert.False(main.HasSubscribers);
Assert.False(other.HasSubscribers);
ts.AssertResult(
new List <int>(new[] { 1, 2, 3 }),
new List <int>(new[] { 4, 5, }),
new List <int>(new[] { 6 })
);
}
public override IPublisher <int> CreatePublisher(long elements)
{
var dp = new DirectProcessor <int>();
Task.Factory.StartNew(() => {
while (!dp.HasSubscribers)
{
Thread.Sleep(10);
}
long start = SchedulerHelper.NowUTC();
for (int i = 0; i < elements; i++)
{
while (!dp.Offer(i))
{
Thread.Sleep(1);
if (SchedulerHelper.NowUTC() - start > 1000)
{
return;
}
}
}
dp.OnComplete();
}, TaskCreationOptions.LongRunning);
return(dp);
}
public void BufferBoundary_Other_Completes_Immediately()
{
var main = new DirectProcessor <int>();
var ts = main.Buffer(Flux.Empty <int>()).Test();
ts.AssertSubscribed()
.AssertResult();
}
public void Cancel()
{
var dp = new DirectProcessor <int>();
var ts = Flowable.Concat(dp).Test();
Assert.IsTrue(dp.HasSubscribers);
ts.Cancel();
Assert.IsFalse(dp.HasSubscribers);
}
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);
}
public void Lockstep()
{
var tex = new TestExecutor();
var dp = new DirectProcessor <int>();
var ts = dp.Debounce(TimeSpan.FromMilliseconds(5), tex).Test();
ts.AssertEmpty();
dp.OnNext(1);
ts.AssertEmpty();
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(5));
ts.AssertValues(1)
.AssertNoError()
.AssertNotComplete();
dp.OnNext(2);
ts.AssertValues(1)
.AssertNoError()
.AssertNotComplete();
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(2));
ts.AssertValues(1)
.AssertNoError()
.AssertNotComplete();
dp.OnNext(3);
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(5));
ts.AssertValues(1, 3)
.AssertNoError()
.AssertNotComplete();
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(2));
dp.OnNext(4);
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(2));
dp.OnComplete();
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(1));
ts.AssertResult(1, 3, 4);
}
public void PublishSelector_Unrelated()
{
var dp = new DirectProcessor <int>();
var ts = dp.Publish(o => Flux.Range(1, 10)).Test(0);
Assert.IsTrue(dp.HasSubscribers, "No subscribers?");
ts.Request(10);
ts.AssertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Assert.IsFalse(dp.HasSubscribers, "Has subscribers?");
}
public void TakeUntil_Normal()
{
var dp1 = new DirectProcessor <int>();
var dp2 = new DirectProcessor <int>();
var ts = dp1.TakeUntil(dp2).Test();
dp1.OnNext(1, 2, 3);
dp2.OnNext(1);
ts.AssertResult(1, 2, 3);
Assert.IsFalse(dp1.HasSubscribers, "dp1 has Subscribers?!");
Assert.IsFalse(dp2.HasSubscribers, "dp2 has Subscribers?!");
}
public void DirectProcessor_Normal()
{
DirectProcessor <int> dp = new DirectProcessor <int>();
var ts = dp.Test();
ts.AssertSubscribed()
.AssertNoEvents();
dp.OnNext(1);
dp.OnNext(2);
dp.OnComplete();
Assert.IsFalse(dp.HasSubscribers);
ts.AssertResult(1, 2);
}
public void Timeout_FirstTimesOut()
{
var first = new DirectProcessor <int>();
var item = new DirectProcessor <int>();
var source = new DirectProcessor <int>();
var ts = source.Timeout(first, v => item, Flux.Just(100))
.Test();
first.OnNext(1);
ts.AssertResult(100);
Assert.IsFalse(first.HasSubscribers, "first has subscribers?!");
Assert.IsFalse(item.HasSubscribers, "item has subscribers?!");
Assert.IsFalse(source.HasSubscribers, "source has subscribers?!");
}
public void SkipUntil_Normal()
{
var dp1 = new DirectProcessor<int>();
var dp2 = new DirectProcessor<int>();
var ts = dp1.SkipUntil(dp2).Test();
dp1.OnNext(1, 2, 3);
dp2.OnNext(1);
dp1.OnNext(4, 5, 6);
dp1.OnComplete();
Assert.IsFalse(dp2.HasSubscribers, "Has subscribers?!");
ts.AssertResult(4, 5, 6);
}
internal Flow <TIn, TOut2, TMat2> DeprecatedAndThenMaterialized <TOut2, TMat2>(Func <Tuple <IProcessor <TIn, TOut2>, TMat2> > factory)
{
var op = new DirectProcessor <TIn, TOut2>(() =>
{
var t = factory();
return(Tuple.Create <IProcessor <TIn, TOut2>, object>(t.Item1, t.Item2));
});
if (IsIdentity)
{
return(new Flow <TIn, TOut2, TMat2>(op));
}
return
(new Flow <TIn, TOut2, TMat2>(
Module.Fuse <TMat, TMat2, TMat2>(op, Shape.Outlet, op.In, Keep.Right)
.ReplaceShape(new FlowShape <TIn, TOut2>(Shape.Inlet, op.Out))));
}
public void Normal()
{
var dp1 = new DirectProcessor <int>();
var dp2 = new DirectProcessor <int>();
var ts = dp1.Buffer(dp2).Test();
ts.AssertEmpty();
dp1.OnNext(1);
dp1.OnNext(2);
dp2.OnNext(100);
ts.AssertValues(
new List <int>(new int[] { 1, 2 })
)
.AssertNoError()
.AssertNotComplete();
dp2.OnNext(200);
ts.AssertValues(
new List <int>(new int[] { 1, 2 }),
new List <int>()
)
.AssertNoError()
.AssertNotComplete();
dp1.OnNext(3);
dp1.OnNext(4);
dp1.OnNext(5);
dp1.OnComplete();
ts.AssertResult(
new List <int>(new int[] { 1, 2 }),
new List <int>(),
new List <int>(new int[] { 3, 4, 5 })
);
Assert.IsFalse(dp2.HasSubscribers);
}
public void NormalConditional()
{
var tex = new TestExecutor();
var dp = new DirectProcessor <int>();
var ts = dp.ThrottleFirst(TimeSpan.FromMilliseconds(5), tex).Filter(v => true).Test();
ts.AssertEmpty();
dp.OnNext(1);
ts.AssertValues(1)
.AssertNoError()
.AssertNotComplete();
dp.OnNext(2);
ts.AssertValues(1)
.AssertNoError()
.AssertNotComplete();
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(5));
ts.AssertValues(1)
.AssertNoError()
.AssertNotComplete();
dp.OnNext(3);
ts.AssertValues(1, 3)
.AssertNoError()
.AssertNotComplete();
dp.OnNext(4);
dp.OnComplete();
ts.AssertResult(1, 3);
tex.AdvanceTimeBy(TimeSpan.FromMilliseconds(5));
ts.AssertResult(1, 3);
}
public void Completing()
{
DirectProcessor <int> dp = new DirectProcessor <int>();
var source = dp.Publish().RefCount(2);
var ts3 = source.Test();
Assert.IsFalse(dp.HasSubscribers);
var ts4 = source.Test();
Assert.IsTrue(dp.HasSubscribers, "ts4 didn't connect?");
dp.OnComplete();
ts3.AssertResult();
ts4.AssertResult();
}
public void OnBackpressureLatest_Normal()
{
var ps = new DirectProcessor <int>();
var ts = ps.OnBackpressureLatest().Test(0);
ps.OnNext(1);
ps.OnNext(2);
ts.Request(1);
ps.OnNext(3);
ts.Request(2);
ps.OnNext(4);
ps.OnComplete();
ts.AssertResult(2, 3, 4);
}
public void Timeout_Conditional_SecondTimesOut()
{
var first = new DirectProcessor <int>();
var item = new DirectProcessor <int>();
var source = new DirectProcessor <int>();
var ts = source.Timeout(first, v => item, Flux.Just(100))
.Filter(v => true)
.Test();
source.OnNext(1);
item.OnNext(1);
ts.AssertResult(1, 100);
Assert.IsFalse(first.HasSubscribers, "first has subscribers?!");
Assert.IsFalse(item.HasSubscribers, "item has subscribers?!");
Assert.IsFalse(source.HasSubscribers, "source has subscribers?!");
}
public void Normal()
{
var dp = new DirectProcessor <int>();
Assert.IsFalse(dp.HasSubscribers);
var ts = dp.Test();
Assert.IsTrue(dp.HasSubscribers);
dp.OnNext(1);
dp.OnNext(2);
dp.OnNext(3);
dp.OnNext(4);
ts.AssertValues(1, 2, 3, 4);
dp.OnComplete();
ts.AssertResult(1, 2, 3, 4);
}
public void Normal()
{
DirectProcessor <int> dp = new DirectProcessor <int>();
var source = dp.Publish().RefCount(2);
var ts1 = source.Test();
Assert.IsFalse(dp.HasSubscribers);
var ts2 = source.Test();
Assert.IsTrue(dp.HasSubscribers, "ts2 didn't connect?");
ts1.Cancel();
Assert.IsTrue(dp.HasSubscribers);
ts2.Cancel();
Assert.IsFalse(dp.HasSubscribers);
}
public void Sample_Normal()
{
var dp1 = new DirectProcessor <int>();
var dp2 = new DirectProcessor <int>();
var ts = dp1.Sample(dp2).Test();
dp1.OnNext(1);
dp1.OnNext(2);
dp2.OnNext(1);
dp2.OnNext(3);
dp1.OnNext(3);
dp2.OnComplete();
ts.AssertResult(2, 3);
Assert.IsFalse(dp1.HasSubscribers, "dp1 has subscribers?!");
Assert.IsFalse(dp2.HasSubscribers, "dp2 has subscribers?!");
}
public void SwitchMap_Normal_Backpressured()
{
var dp = new DirectProcessor <int>();
var ts = dp.SwitchMap(v => Flux.Range(v, 2))
.Test(initialRequest: 1);
dp.OnNext(1);
dp.OnNext(2);
ts.Request(1);
dp.OnNext(3);
ts.Request(1);
dp.OnComplete();
ts.Request(1);
ts.AssertResult(1, 2, 3, 4);
}
public void WithLatestFrom_Normal()
{
var dp1 = new DirectProcessor <int>();
var dp2 = new DirectProcessor <int>();
var ts = dp1.WithLatestFrom(dp2, (a, b) => a + b).Test();
dp1.OnNext(1);
dp2.OnNext(10);
dp1.OnNext(2, 3, 4);
dp2.OnNext(20);
dp1.OnNext(5);
dp1.OnComplete();
ts.AssertResult(12, 13, 14, 25);
Assert.IsFalse(dp1.HasSubscribers, "dp1 has subscribers?");
Assert.IsFalse(dp2.HasSubscribers, "dp2 has subscribers?");
}
public override void Subscribe(IFlowableSubscriber <T> subscriber)
{
var dp = new DirectProcessor <Exception>();
IPublisher <U> p;
try
{
p = handler(dp);
}
catch (Exception ex)
{
subscriber.OnSubscribe(EmptySubscription <T> .Instance);
subscriber.OnError(ex);
return;
}
var parent = new RetryWhenSubscriber(subscriber, dp, source);
subscriber.OnSubscribe(parent);
p.Subscribe(parent.handler);
parent.Subscribe();
}
