public FlowTakeSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
Materializer = ActorMaterializer.Create(Sys, settings);
MuteDeadLetters(typeof(OnNext), typeof(OnComplete), typeof(RequestMore));
}
public FlowSelectSpec(ITestOutputHelper output) : base(output)
{
Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
_settings = ActorMaterializerSettings.Create(Sys)
.WithInputBuffer(initialSize: 2, maxSize: 16);
_materializer = Sys.Materializer(_settings);
}
public void Setup(BenchmarkContext context)
{
_actorSystem = ActorSystem.Create("MaterializationBenchmark",
ConfigurationFactory.FromResource<AkkaSpec>("Akka.Streams.TestKit.Tests.reference.conf"));
_actorSystem.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
_materializerSettings =
ActorMaterializerSettings.Create(_actorSystem).WithDispatcher("akka.test.stream-dispatcher");
_materializer = _actorSystem.Materializer(_materializerSettings);
}
public FlowLogSpec(ITestOutputHelper helper) : base("akka.loglevel = DEBUG", helper)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
Materializer = ActorMaterializer.Create(Sys, settings);
var p = CreateTestProbe();
Sys.EventStream.Subscribe(p.Ref, typeof(object));
LogProbe = p;
}
public FlowSplitAfterSpec(ITestOutputHelper helper) : base(helper)
{
var settings =
ActorMaterializerSettings.Create(Sys)
.WithInputBuffer(2, 2)
.WithSubscriptionTimeoutSettings(
new StreamSubscriptionTimeoutSettings(
StreamSubscriptionTimeoutTerminationMode.CancelTermination, TimeSpan.FromSeconds(1)));
Materializer = ActorMaterializer.Create(Sys, settings);
}
public void Setup(BenchmarkContext context)
{
_actorSystem = ActorSystem.Create("FileSourcesBenchmark");
_materializer = _actorSystem.Materializer();
_file = CreateFile();
_fileChannelSource = FileIO.FromFile(_file, BufferSize);
_fileInputStreamSource = StreamConverters.FromInputStream(() => File.OpenRead(_file.FullName), BufferSize);
_ioSourceLinesIterator = Source.FromEnumerator(() => File.ReadLines(_file.FullName).Select(ByteString.FromString).GetEnumerator());
}
public FileSourceSpec(ITestOutputHelper helper) : base(Utils.UnboundedMailboxConfig, helper)
{
Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
var settings = ActorMaterializerSettings.Create(Sys).WithDispatcher("akka.actor.default-dispatcher");
_materializer = Sys.Materializer(settings);
var sb = new StringBuilder(6000);
foreach (var character in new[] { "a", "b", "c", "d", "e", "f" })
for (var i = 0; i < 1000; i++)
sb.Append(character);
_testText = sb.ToString();
}
public FileSinkSpec(ITestOutputHelper helper) : base(Utils.UnboundedMailboxConfig, helper)
{
Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
var settings = ActorMaterializerSettings.Create(Sys).WithDispatcher("akka.actor.default-dispatcher");
_materializer = Sys.Materializer(settings);
foreach (var character in new[] { "a", "b", "c", "d", "e", "f" })
{
var line = "";
for (var i = 0; i < 1000; i++)
line += character;
// don't use Environment.NewLine - it can contain more than one byte length marker,
// causing tests to fail due to incorrect number of bytes in input string
line += "\n";
_testLines.Add(line);
}
_testByteStrings = _testLines.Select(ByteString.FromString).ToList();
}
public void Setup(BenchmarkContext context)
{
_actorSystem = ActorSystem.Create("MergeManyBenchmark",
ConfigurationFactory.FromResource<ScriptedTest>("Akka.Streams.TestKit.Tests.reference.conf"));
_actorSystem.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
_materializerSettings = ActorMaterializerSettings.Create(_actorSystem).WithDispatcher("akka.test.stream-dispatcher");
_materializer = _actorSystem.Materializer(_materializerSettings);
var takeSource = CreateSource(NumberOfElements);
var singleSubSource = CreateSource(NumberOfElements);
var singleSource = Source.Repeat(0).Take(1).MergeMany(1, _ => singleSubSource);
var tenSubSources = CreateSource(NumberOfElements/10);
var tenSources = Source.Repeat(0).Take(10).MergeMany(10, _ => tenSubSources);
_takeGraph = ToSource(takeSource);
_singleGraph = ToSource(singleSource);
_tenGraph = ToSource(tenSources);
}
public TickSourceSpec()
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public void A_Flow_with_multiple_subscribers_FanOutBox_must_support_slow_subscriber_with_fan_out_2()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings),
(source, materializer) => ToFanoutPublisher(source, materializer, 2), this);
var downstream2 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream2);
var downstream2Subscription = downstream2.ExpectSubscription();
setup.DownstreamSubscription.Request(5);
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1); // because initialInputBufferSize=1
setup.UpstreamSubscription.SendNext("element1");
setup.Downstream.ExpectNext("element1");
setup.UpstreamSubscription.ExpectRequest(1);
setup.UpstreamSubscription.SendNext("element2");
setup.Downstream.ExpectNext("element2");
setup.UpstreamSubscription.ExpectRequest(1);
setup.UpstreamSubscription.SendNext("element3");
// downstream2 has not requested anything, fan-out buffer 2
setup.Downstream.ExpectNoMsg(Dilated(TimeSpan.FromMilliseconds(100)));
downstream2Subscription.Request(2);
setup.Downstream.ExpectNext("element3");
downstream2.ExpectNext("element1");
downstream2.ExpectNext("element2");
downstream2.ExpectNoMsg(Dilated(TimeSpan.FromMilliseconds(100)));
setup.UpstreamSubscription.Request(1);
setup.UpstreamSubscription.SendNext("element4");
setup.Downstream.ExpectNext("element4");
downstream2Subscription.Request(2);
downstream2.ExpectNext("element3");
downstream2.ExpectNext("element4");
setup.UpstreamSubscription.SendComplete();
setup.Downstream.ExpectComplete();
downstream2.ExpectComplete();
}
public void A_Flow_must_deliver_error_signal_when_publisher_immediately_fails()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings,
(settings, factory) => ActorMaterializer.Create(factory, settings), ToPublisher, this);
var weirdError = new Exception("weird test exception");
setup.UpstreamSubscription.SendError(weirdError);
setup.Downstream.ExpectError().Should().Be(weirdError);
}
protected AllPersistenceIdsSpec(Config config, ITestOutputHelper output) : base(config, output: output)
{
_materializer = Sys.Materializer();
_queries = Sys.ReadJournalFor<SqlReadJournal>(SqlReadJournal.Identifier);
}
public void A_Flow_must_request_more_elements_from_upstream_when_downstream_requests_more_elements()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings,
(settings, factory) => ActorMaterializer.Create(factory, settings), ToPublisher, this);
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, Settings.MaxInputBufferSize);
setup.DownstreamSubscription.Request(1);
setup.Upstream.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
setup.DownstreamSubscription.Request(2);
setup.Upstream.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
setup.UpstreamSubscription.SendNext("a");
setup.Downstream.ExpectNext("a");
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.Upstream.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
setup.UpstreamSubscription.SendNext("b");
setup.UpstreamSubscription.SendNext("c");
setup.UpstreamSubscription.SendNext("d");
setup.Downstream.ExpectNext("b");
setup.Downstream.ExpectNext("c");
}
public void A_Flow_must_cancel_upstream_when_single_subscriber_cancels_subscription_while_receiving_data()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings), ToPublisher, this);
setup.DownstreamSubscription.Request(5);
setup.UpstreamSubscription.ExpectRequest(1);
setup.UpstreamSubscription.SendNext("test");
setup.UpstreamSubscription.ExpectRequest(1);
setup.UpstreamSubscription.SendNext("test2");
setup.Downstream.ExpectNext("test");
setup.Downstream.ExpectNext("test2");
setup.DownstreamSubscription.Cancel();
// because of the "must cancel its upstream Subscription if its last downstream Subscription has been canceled" rule
setup.UpstreamSubscription.ExpectCancellation();
}
private static IPublisher <TOut> ToFanoutPublisher <TOut, TMat>(Source <TOut, TMat> source,
ActorMaterializer materializer, int elasticity)
=>
source.RunWith(
Sink.AsPublisher <TOut>(true).WithAttributes(Attributes.CreateInputBuffer(elasticity, elasticity)),
materializer);
private static (ISubscriber <TIn>, IPublisher <TOut>) MaterializeIntoSubscriberAndPublisher <TIn, TOut, TMat>(
Flow <TIn, TOut, TMat> flow, ActorMaterializer materializer)
=> flow.RunWith(Source.AsSubscriber <TIn>(), Sink.AsPublisher <TOut>(false), materializer);
private static IPublisher <TOut> ToPublisher <TOut, TMat>(Source <TOut, TMat> source,
ActorMaterializer materializer) => source.RunWith(Sink.AsPublisher <TOut>(false), materializer);
public void A_broken_Flow_must_cancel_upstream_and_call_onError_on_current_and_future_downstream_subscribers_if_an_internal_error_occurs()
{
var setup = new ChainSetup <string, string, NotUsed>(FaultyFlow <string, string, string>, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings),
(source, materializer) => ToFanoutPublisher(source, materializer, 16), this);
Action <TestSubscriber.ManualProbe <string> > checkError = sprobe =>
{
var error = sprobe.ExpectError();
error.Should().BeOfType <AbruptTerminationException>();
error.Message.Should().StartWith("Processor actor");
};
var downstream2 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream2);
var downstream2Subscription = downstream2.ExpectSubscription();
setup.DownstreamSubscription.Request(5);
downstream2Subscription.Request(5);
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("a1");
setup.Downstream.ExpectNext("a1");
downstream2.ExpectNext("a1");
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("a2");
setup.Downstream.ExpectNext("a2");
downstream2.ExpectNext("a2");
var filters = new EventFilterBase[]
{
new ErrorFilter(typeof(NullReferenceException)),
new ErrorFilter(typeof(IllegalStateException)),
new ErrorFilter(typeof(PostRestartException)),// This is thrown because we attach the dummy failing actor to toplevel
};
try
{
Sys.EventStream.Publish(new Mute(filters));
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("a3");
setup.UpstreamSubscription.ExpectCancellation();
// IllegalStateException terminated abruptly
checkError(setup.Downstream);
checkError(downstream2);
var downstream3 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream3);
downstream3.ExpectSubscription();
// IllegalStateException terminated abruptly
checkError(downstream3);
}
finally
{
Sys.EventStream.Publish(new Unmute(filters));
}
}
public void A_Flow_with_multiple_subscribers_FanOutBox_must_call_future_subscribers_OnError_when_all_subscriptions_were_cancelled()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings),
(source, materializer) => ToFanoutPublisher(source, materializer, 16), this);
// make sure stream is initialized before canceling downstream
Thread.Sleep(100);
setup.UpstreamSubscription.ExpectRequest(1);
setup.DownstreamSubscription.Cancel();
setup.UpstreamSubscription.ExpectCancellation();
var downstream2 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream2);
// IllegalStateException shut down
downstream2.ExpectSubscriptionAndError().Should().BeAssignableTo <IllegalStateException>();
}
public PublisherSinkSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public override IProcessor <int?, int?> CreateIdentityProcessor(int bufferSize)
{
var materializer = ActorMaterializer.Create(System);
return(Flow.Create <int?>().Select(x => x).Named("identity").ToProcessor().Run(materializer));
}
public FlowSupervisionSpec(ITestOutputHelper helper) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public QueueSinkSpec(ITestOutputHelper output) : base(output)
{
_materializer = Sys.Materializer();
}
public FlowSkipWithinSpec(ITestOutputHelper helper) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public BidiFlowSpec()
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public void A_Flow_with_multiple_subscribers_FanOutBox_must_call_future_subscribers_OnError_after_OnSubscribe_if_initial_upstream_was_completed()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings),
(source, materializer) => ToFanoutPublisher(source, materializer, 1), this);
var downstream2 = this.CreateManualSubscriberProbe <string>();
// don't link it just yet
setup.DownstreamSubscription.Request(5);
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("a1");
setup.Downstream.ExpectNext("a1");
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("a2");
setup.Downstream.ExpectNext("a2");
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
// link now while an upstream element is already requested
setup.Publisher.Subscribe(downstream2);
var downstream2Subscription = downstream2.ExpectSubscription();
setup.UpstreamSubscription.SendNext("a3");
setup.UpstreamSubscription.SendComplete();
setup.Downstream.ExpectNext("a3");
setup.Downstream.ExpectComplete();
downstream2.ExpectNoMsg(Dilated(TimeSpan.FromMilliseconds(100))); // as nothing was requested yet, fanOutBox needs to cache element in this case
downstream2Subscription.Request(1);
downstream2.ExpectNext("a3");
downstream2.ExpectComplete();
var downstream3 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream3);
downstream3.ExpectSubscription();
downstream3.ExpectError().Should().BeOfType <NormalShutdownException>();
}
public GraphStageTimersSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public TimeoutsSpec(ITestOutputHelper helper = null) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public FlowIdleInjectSpec(ITestOutputHelper helper) : base(helper)
{
Settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
Materializer = ActorMaterializer.Create(Sys, Settings);
}
public void A_Flow_with_multiple_subscribers_FanOutBox_must_be_unblocked_when_blocking_subscriber_cancels_subscription()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings),
(source, materializer) => ToFanoutPublisher(source, materializer, 1), this);
var downstream2 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream2);
var downstream2Subscription = downstream2.ExpectSubscription();
setup.DownstreamSubscription.Request(5);
setup.UpstreamSubscription.ExpectRequest(1);
setup.UpstreamSubscription.SendNext("firstElement");
setup.Downstream.ExpectNext("firstElement");
downstream2Subscription.Request(1);
downstream2.ExpectNext("firstElement");
setup.UpstreamSubscription.ExpectRequest(1);
setup.UpstreamSubscription.SendNext("element2");
setup.Downstream.ExpectNext("element2");
setup.UpstreamSubscription.ExpectRequest(1);
setup.UpstreamSubscription.SendNext("element3");
setup.UpstreamSubscription.ExpectRequest(1);
setup.Downstream.ExpectNoMsg(Dilated(TimeSpan.FromMilliseconds(200)));
setup.Upstream.ExpectNoMsg(Dilated(TimeSpan.FromMilliseconds(200)));
downstream2.ExpectNoMsg(Dilated(TimeSpan.FromMilliseconds(200)));
// should unblock fanoutbox
downstream2Subscription.Cancel();
setup.Downstream.ExpectNext("element3");
setup.UpstreamSubscription.SendNext("element4");
setup.Downstream.ExpectNext("element4");
setup.UpstreamSubscription.SendComplete();
setup.Downstream.ExpectComplete();
}
public FlowSupervisionSpec(ITestOutputHelper helper) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public void A_Flow_with_multiple_subscribers_FanOutBox_must_support_incoming_subscriber_while_elements_were_requested_before()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings),
(source, materializer) => ToFanoutPublisher(source, materializer, 1), this);
setup.DownstreamSubscription.Request(5);
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("a1");
setup.Downstream.ExpectNext("a1");
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("a2");
setup.Downstream.ExpectNext("a2");
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
// link now while an upstream element is already requested
var downstream2 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream2);
var downstream2Subscription = downstream2.ExpectSubscription();
// situation here:
// downstream 1 now has 3 outstanding
// downstream 2 has 0 outstanding
setup.UpstreamSubscription.SendNext("a3");
setup.Downstream.ExpectNext("a3");
downstream2.ExpectNoMsg(Dilated(TimeSpan.FromMilliseconds(100))); // as nothing was requested yet, fanOutBox needs to cache element in this case
downstream2Subscription.Request(1);
downstream2.ExpectNext("a3");
// d1 now has 2 outstanding
// d2 now has 0 outstanding
// buffer should be empty so we should be requesting one new element
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1); // because of buffer size 1
}
public FlowForeachSpec(ITestOutputHelper helper) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public FlowForeachSpec(ITestOutputHelper helper) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public TestPublisherSubscriberSpec(ITestOutputHelper output = null) : base(output)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(initialSize: 2, maxSize: 2);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public FlowSelectAsyncUnorderedSpec(ITestOutputHelper helper) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public KeepGoingStageSpec(ITestOutputHelper helper = null) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public OutputStreamSinkSpec(ITestOutputHelper helper) : base(Utils.UnboundedMailboxConfig, helper)
{
Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
var settings = ActorMaterializerSettings.Create(Sys).WithDispatcher("akka.actor.default-dispatcher");
_materializer = Sys.Materializer(settings);
}
public ActorRefSinkSpec(ITestOutputHelper output) : base(output)
{
materializer = Sys.Materializer();
}
public void A_Flow_with_multiple_subscribers_FanOutBox_must_adapt_speed_to_the_currently_slowest_subscriber()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings.WithInputBuffer(1, 1),
(settings, factory) => ActorMaterializer.Create(factory, settings),
(source, materializer) => ToFanoutPublisher(source, materializer, 1), this);
var downstream2 = this.CreateManualSubscriberProbe <string>();
setup.Publisher.Subscribe(downstream2);
var downstream2Subscription = downstream2.ExpectSubscription();
setup.DownstreamSubscription.Request(5);
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1); // because initialInputBufferSize=1
setup.UpstreamSubscription.SendNext("firstElement");
setup.Downstream.ExpectNext("firstElement");
setup.Upstream.ExpectRequest(setup.UpstreamSubscription, 1);
setup.UpstreamSubscription.SendNext("element2");
setup.Downstream.ExpectNoMsg(TimeSpan.FromSeconds(1));
downstream2Subscription.Request(1);
downstream2.ExpectNext("firstElement");
setup.Downstream.ExpectNext("element2");
downstream2Subscription.Request(1);
downstream2.ExpectNext("element2");
}
public FlowGroupedWithinSpec(ITestOutputHelper helper) : base(helper)
{
Settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, Settings);
}
public SubscriberSourceSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public GraphBalanceSpec()
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public SubscriberSinkSpec(ITestOutputHelper helper = null) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
Materializer = ActorMaterializer.Create(Sys,settings);
}
public FlowSelectManySpec(ITestOutputHelper output) : base(output)
{
settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(initialSize: 2, maxSize: 16);
materializer = Sys.Materializer();
}
public SourceSpec(ITestOutputHelper helper) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public FlowSpec(ITestOutputHelper helper) : base(Config.WithFallback(ConfigurationFactory.FromResource <ScriptedTest>("Akka.Streams.TestKit.Tests.reference.conf")), helper)
{
Settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 2);
Materializer = ActorMaterializer.Create(Sys, Settings);
}
public BidiFlowSpec()
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public TimeoutsSpec(ITestOutputHelper helper = null) : base(helper)
{
Materializer = ActorMaterializer.Create(Sys);
}
public GraphUnzipSpec(ITestOutputHelper helper) : base (helper)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public SubscriberSourceSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public SubstreamSubscriptionTimeoutSpec(ITestOutputHelper helper) : base(Config, helper)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 2);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public FlowLimitWeightedSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public FlowPrefixAndTailSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2,2);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public RestartSpec(ITestOutputHelper output) : base("", output)
{
Materializer = Sys.Materializer();
}
public FlowExpandSpec(ITestOutputHelper helper) : base(helper)
{
Settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 2);
Materializer = ActorMaterializer.Create(Sys, Settings);
}
public FlowCollectSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public FlowFromTaskSpec(ITestOutputHelper helper) : base(helper)
{
var settings = ActorMaterializerSettings.Create(Sys);
Materializer = ActorMaterializer.Create(Sys, settings);
}
public void A_Flow_must_deliver_complete_signal_when_publisher_immediately_completes()
{
var setup = new ChainSetup <string, string, NotUsed>(Identity, Settings,
(settings, factory) => ActorMaterializer.Create(factory, settings), ToPublisher, this);
setup.UpstreamSubscription.SendComplete();
setup.Downstream.ExpectComplete();
}
