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));
}
public FlowGroupedSpec(ITestOutputHelper output = null) : base(output)
{
Settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
}