private static void Execute(int numberOfIdentities)
{
new GraphInterpreterSpecKit().WithTestSetup((setup, lastEvents) =>
{
var identities =
Enumerable.Range(1, numberOfIdentities)
.Select(_ => GraphStages.Identity <int>())
.Cast <IGraphStageWithMaterializedValue <Shape, object> >()
.ToArray();
var source = new GraphDataSource <int>("source", Data100K);
var sink = new GraphDataSink <int>("sink", Data100K.Length);
var b = setup.Builder(identities)
.Connect(source, identities[0].Shape.Inlets[0] as Inlet <int>)
.Connect(identities.Last().Shape.Outlets[0] as Outlet <int>, sink);
// FIXME: This should not be here, this is pure setup overhead
for (var i = 0; i < identities.Length - 1; i++)
{
b.Connect(identities[i].Shape.Outlets[0] as Outlet <int>,
identities[i + 1].Shape.Inlets[0] as Inlet <int>);
}
b.Init();
sink.RequestOne();
setup.Interpreter.Execute(int.MaxValue);
});
}
public GraphInterpreterSpec(ITestOutputHelper output = null) : base(output)
{
_identity = GraphStages.Identity <int>();
_detach = new Detacher <int>();
_zip = new Zip <int, string>();
_broadcast = new Broadcast <int>(2);
_merge = new Merge <int>(2);
_balance = new Balance <int>(2);
}
public override IProcessor <int?, int?> CreateIdentityProcessor(int bufferSize)
{
var settings = ActorMaterializerSettings.Create(System).WithInputBuffer(bufferSize / 2, bufferSize);
var materializer = ActorMaterializer.Create(System, settings);
// withAttributes "wraps" the underlying identity and protects it from automatic removal
return(Flow.Create <int?>()
.Via(GraphStages.Identity <int?>())
.Named("identity")
.ToProcessor()
.Run(materializer));
}
/// <summary>
/// Transform this <see cref="Source{TOut,TMat}"/> by appending the given processing steps.
/// The <paramref name="combine"/> function is used to compose the materialized values of this flow and that
/// flow into the materialized value of the resulting Flow.
/// </summary>
/// <typeparam name="TOut2">TBD</typeparam>
/// <typeparam name="TMat2">TBD</typeparam>
/// <typeparam name="TMat3">TBD</typeparam>
/// <param name="flow">TBD</param>
/// <param name="combine">TBD</param>
/// <returns>TBD</returns>
public Source <TOut2, TMat3> ViaMaterialized <TOut2, TMat2, TMat3>(IGraph <FlowShape <TOut, TOut2>, TMat2> flow, Func <TMat, TMat2, TMat3> combine)
{
if (flow.Module == GraphStages.Identity <TOut2>().Module)
{
return(this as Source <TOut2, TMat3>);
}
var flowCopy = flow.Module.CarbonCopy();
return(new Source <TOut2, TMat3>(Module
.Fuse(flowCopy, Shape.Outlet, flowCopy.Shape.Inlets.First(), combine)
.ReplaceShape(new SourceShape <TOut2>((Outlet <TOut2>)flowCopy.Shape.Outlets.First()))));
}
public void A_Graph_should_suitably_override_attribute_handling_methods()
{
var ga = GraphDsl.Create(b =>
{
var id = b.Add(GraphStages.Identity <int>());
return(new FlowShape <int, int>(id.Inlet, id.Outlet));
}).Async().AddAttributes(Attributes.None).Named("useless");
ga.Module.Attributes.GetFirstAttribute <Attributes.Name>().Value.Should().Be("useless");
ga.Module.Attributes.GetFirstAttribute <Attributes.AsyncBoundary>()
.Should()
.Be(Attributes.AsyncBoundary.Instance);
}
public void ActorGraphInterpreter_should_be_able_to_interpret_a_simple_identity_graph_stage()
{
this.AssertAllStagesStopped(() =>
{
var identity = GraphStages.Identity <int>();
var task = Source.From(Enumerable.Range(1, 100))
.Via(identity)
.Grouped(200)
.RunWith(Sink.First <IEnumerable <int> >(), Materializer);
task.AwaitResult().Should().Equal(Enumerable.Range(1, 100));
}, Materializer);
}
public void ActorGraphInterpreter_should_be_able_to_reuse_a_simple_identity_graph_stage()
{
this.AssertAllStagesStopped(() =>
{
var identity = GraphStages.Identity <int>();
var task = Source.From(Enumerable.Range(1, 100))
.Via(identity)
.Via(identity)
.Via(identity)
.Grouped(200)
.RunWith(Sink.First <IEnumerable <int> >(), _materializer);
task.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
task.Result.Should().Equal(Enumerable.Range(1, 100));
}, _materializer);
}
private void Execute(ActorMaterializer actorMaterializer, int numberOfSelectOps, bool useGraphStageIdentity)
{
var syncTestPublisher = new SyncTestPublisher();
var flow = MakeSelects(Source.FromPublisher(syncTestPublisher), numberOfSelectOps, () =>
{
if (useGraphStageIdentity)
{
return(GraphStages.Identity <int>());
}
return(Flow.Create <int>().Select(x => x));
});
var l = new AtomicBoolean();
flow.RunWith(Sink.OnComplete <int>(() => l.Value = true, _ => { }), actorMaterializer);
while (!l.Value)
{
Thread.Sleep(10);
}
}
/// <summary>
/// Transform this <see cref="Source{TOut,TMat}"/> by appending the given processing steps.
/// The <paramref name="combine"/> function is used to compose the materialized values of this flow and that
/// flow into the materialized value of the resulting Flow.
/// </summary>
/// <typeparam name="TOut2">TBD</typeparam>
/// <typeparam name="TMat2">TBD</typeparam>
/// <typeparam name="TMat3">TBD</typeparam>
/// <param name="flow">TBD</param>
/// <param name="combine">TBD</param>
/// <returns>TBD</returns>
public Source <TOut2, TMat3> ViaMaterialized <TOut2, TMat2, TMat3>(IGraph <FlowShape <TOut, TOut2>, TMat2> flow, Func <TMat, TMat2, TMat3> combine)
{
if (flow.Module == GraphStages.Identity <TOut2>().Module)
{
if (Keep.IsLeft(combine))
{
return(this as Source <TOut2, TMat3>);
}
if (Keep.IsRight(combine))
{
return(MapMaterializedValue(_ => NotUsed.Instance) as Source <TOut2, TMat3>);
}
return(MapMaterializedValue(value => combine(value, (TMat2)(object)NotUsed.Instance)) as Source <TOut2, TMat3>);
}
var flowCopy = flow.Module.CarbonCopy();
return(new Source <TOut2, TMat3>(Module
.Fuse(flowCopy, Shape.Outlet, flowCopy.Shape.Inlets.First(), combine)
.ReplaceShape(new SourceShape <TOut2>((Outlet <TOut2>)flowCopy.Shape.Outlets.First()))));
}