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 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 FlowSelectErrorSpec() { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(1, 1); Materializer = Sys.Materializer(settings); }
public FlowWhereSpec(ITestOutputHelper helper) : base(helper) { 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 FlowIdleInjectSpec(ITestOutputHelper helper) : base(helper) { Settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16); Materializer = ActorMaterializer.Create(Sys, Settings); }
public BidiFlowSpec() { var settings = ActorMaterializerSettings.Create(Sys); Materializer = ActorMaterializer.Create(Sys, settings); }
public SinkForeachParallelSpec(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 ChasingEventsSpec(ITestOutputHelper output = null) : base(output) { Materializer = Sys.Materializer(ActorMaterializerSettings.Create(Sys).WithFuzzingMode(false)); }
protected AkkaSubscriberWhiteboxVerification(TestEnvironment environment) : base(environment) { System = ActorSystem.Create(GetType().Name, AkkaSpec.AkkaSpecConfig); System.EventStream.Publish(new Mute(new ErrorFilter(typeof(Exception), new ContainsString("Test exception")))); Materializer = ActorMaterializer.Create(System, ActorMaterializerSettings.Create(System)); }
public static IBuffer <T> Create <T>(int size, ActorMaterializerSettings settings) => Create <T>(size, settings.MaxFixedBufferSize);
public void GroupBy_must_work_with_random_demand() { this.AssertAllStagesStopped(() => { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(1, 1); var materializer = Sys.Materializer(settings); var props = new RandomDemandProperties { Kit = this }; Enumerable.Range(0, 100) .ToList() .ForEach(_ => props.Probes.Add(new TaskCompletionSource <TestSubscriber.Probe <ByteString> >())); var map = new Dictionary <int, SubFlowState>(); var publisherProbe = this.CreateManualPublisherProbe <ByteString>(); var probeShape = new SinkShape <ByteString>(new Inlet <ByteString>("ProbeSink.in")); var probeSink = new ProbeSink(probeShape, props, Attributes.None); Source.FromPublisher(publisherProbe) .GroupBy(100, element => Math.Abs(element[0] % 100)) .To(new Sink <ByteString, TestSubscriber.Probe <ByteString> >(probeSink)) .Run(materializer); var upstreamSubscription = publisherProbe.ExpectSubscription(); for (var i = 1; i <= 400; i++) { var byteString = RandomByteString(10); var index = Math.Abs(byteString[0] % 100); upstreamSubscription.ExpectRequest(); upstreamSubscription.SendNext(byteString); if (map.TryGetValue(index, out var state)) { if (state.FirstElement != null) //first element in subFlow { if (!state.HasDemand) { props.BlockingNextElement = byteString; } RandomDemand(map, props); } else if (state.HasDemand) { if (props.BlockingNextElement == null) { state.Probe.ExpectNext().ShouldBeEquivalentTo(byteString); map[index] = new SubFlowState(state.Probe, false, null); RandomDemand(map, props); } else { true.ShouldBeFalse("INVALID CASE"); } } else { props.BlockingNextElement = byteString; RandomDemand(map, props); } } else { var probe = props.Probes[props.ProbesReaderTop].Task.AwaitResult(); props.ProbesReaderTop++; map[index] = new SubFlowState(probe, false, byteString); //stream automatically requests next element } } upstreamSubscription.SendComplete(); }, Materializer); }
public FlowStatefulSelectManySpec() { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16); Materializer = ActorMaterializer.Create(Sys, settings); }
public FlowWatchTerminationSpec(ITestOutputHelper helper) : base(helper) { var settings = ActorMaterializerSettings.Create(Sys); 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 FlowSkipWhileSpec(ITestOutputHelper helper) : base(helper) { var settings = ActorMaterializerSettings.Create(Sys); Materializer = ActorMaterializer.Create(Sys, settings); }
public FlowSlidingSpec() { 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 FlowGroupedSpec(ITestOutputHelper output = null) : base(output) { Settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16); }
public void Setup(BenchmarkContext context) { _system = ActorSystem.Create("Test"); var settings = ActorMaterializerSettings.Create(_system) .WithFuzzingMode(false) .WithSyncProcessingLimit(int.MaxValue) .WithAutoFusing(false); // We fuse manually in this test in the setup _materializer = _system.Materializer(settings); _testElements = Enumerable.Repeat(0, ElementCount).Select(i => new MutableElement(i)).ToArray(); var testSource = Source.FromGraph(new TestSource(_testElements)); var testSink = Sink.FromGraph(new CompletionLatch()); var identityStage = new IdentityStage(); _singleIdentity = Fuse(testSource.Via(identityStage).ToMaterialized(testSink, Keep.Right)); _chainOfIdentities = Fuse( testSource.Via(identityStage) .Via(identityStage) .Via(identityStage) .Via(identityStage) .Via(identityStage) .Via(identityStage) .Via(identityStage) .Via(identityStage) .Via(identityStage) .Via(identityStage) .ToMaterialized(testSink, Keep.Right)); _singleSelect = Fuse(testSource.Select(Add).ToMaterialized(testSink, Keep.Right)); _chainOfSelects = Fuse( testSource.Select(Add) .Select(Add) .Select(Add) .Select(Add) .Select(Add) .Select(Add) .Select(Add) .Select(Add) .Select(Add) .Select(Add) .ToMaterialized(testSink, Keep.Right)); _repeatTakeSelectAndAggregate = Fuse(Source.Repeat(new MutableElement(0)) .Take(ElementCount) .Select(Add) .Select(Add) .Aggregate(new MutableElement(0), (acc, x) => { acc.Value += x.Value; return(acc); }).ToMaterialized(testSink, Keep.Right)); _singleBuffer = Fuse(testSource.Buffer(10, OverflowStrategy.Backpressure).ToMaterialized(testSink, Keep.Right)); _chainOfBuffers = Fuse( testSource.Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .Buffer(10, OverflowStrategy.Backpressure) .ToMaterialized(testSink, Keep.Right)); var broadcastZipFLow = Flow.FromGraph(GraphDsl.Create(b => { var bcast = b.Add(new Broadcast <MutableElement>(2)); var zip = b.Add(new Zip <MutableElement, MutableElement>()); b.From(bcast).To(zip.In0); b.From(bcast).To(zip.In1); var outlet = b.From(zip.Out).Via(Flow.Create <(MutableElement, MutableElement)>().Select(t => t.Item1)); return(new FlowShape <MutableElement, MutableElement>(bcast.In, outlet.Out)); })); var balanceMergeFlow = Flow.FromGraph(GraphDsl.Create(b => { var balance = b.Add(new Balance <MutableElement>(2)); var merge = b.Add(new Merge <MutableElement>(2)); b.From(balance).To(merge); b.From(balance).To(merge); return(new FlowShape <MutableElement, MutableElement>(balance.In, merge.Out)); })); _broadcastZip = Fuse(testSource.Via(broadcastZipFLow).ToMaterialized(testSink, Keep.Right)); _balanceMerge = Fuse(testSource.Via(balanceMergeFlow).ToMaterialized(testSink, Keep.Right)); _broadcastZipBalanceMerge = Fuse(testSource.Via(broadcastZipFLow).Via(balanceMergeFlow).ToMaterialized(testSink, Keep.Right)); }
public FlowRecoverWithSpec(ITestOutputHelper helper) : base(helper) { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(1, 1); Materializer = ActorMaterializer.Create(Sys, settings); }
public ReverseArrowSpec() { var settings = ActorMaterializerSettings.Create(Sys); Materializer = ActorMaterializer.Create(Sys, settings); }
public GraphUnzipSpec(ITestOutputHelper helper) : base(helper) { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16); Materializer = ActorMaterializer.Create(Sys, settings); }
public FlowGroupBySpec(ITestOutputHelper helper) : base(helper) { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 2); Materializer = ActorMaterializer.Create(Sys, settings); }
/// <summary> /// TBD /// </summary> /// <typeparam name="T">TBD</typeparam> /// <param name="settings">TBD</param> /// <returns>TBD</returns> public static Props Props <T>(ActorMaterializerSettings settings) => Actor.Props.Create(() => new Unzip <T>(settings, 2)).WithDeploy(Deploy.Local);
private IMaterializer CreateMaterializer(bool autoFusing) { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16).WithAutoFusing(autoFusing); return(Sys.Materializer(settings)); }
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 FlowGroupedWithinSpec(ITestOutputHelper helper) : base(helper) { Settings = ActorMaterializerSettings.Create(Sys); Materializer = ActorMaterializer.Create(Sys, Settings); }
protected AbstractFlowIteratorSpec(ITestOutputHelper helper) : base(helper) { var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 2); Materializer = ActorMaterializer.Create(Sys, settings); }
public GraphDslCompileSpec(ITestOutputHelper helper) : base(helper) { var settings = ActorMaterializerSettings.Create(Sys); Materializer = ActorMaterializer.Create(Sys, settings); }
/// <summary> /// TBD /// </summary> /// <param name="settings">TBD</param> /// <param name="haveShutdown">TBD</param> /// <returns>TBD</returns> public static Props Props(ActorMaterializerSettings settings, AtomicBoolean haveShutdown) => Actor.Props.Create(() => new StreamSupervisor(settings, haveShutdown)).WithDeploy(Deploy.Local);
public FlowDispatcherSpec(ITestOutputHelper helper) : base("my-dispatcher = akka.test.stream-dispatcher", helper) { _defaultSettings = ActorMaterializerSettings.Create(Sys); }
/// <summary> /// TBD /// </summary> /// <param name="settings">TBD</param> /// <param name="haveShutdown">TBD</param> public StreamSupervisor(ActorMaterializerSettings settings, AtomicBoolean haveShutdown) { Settings = settings; HaveShutdown = haveShutdown; }
public StreamLayoutSpec(ITestOutputHelper output) : base(output: output) { Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig()); _materializer = ActorMaterializer.Create(Sys, ActorMaterializerSettings.Create(Sys).WithAutoFusing(false)); }