public void Concat()
{
var part1 = new InputPipe <List <int> >("part1");
var part2 = new InputPipe <int[]>("part2");
var concatWithPipeline = part1.ConcatWith(part2);
var collector = concatWithPipeline.Collect();
PipelineApprovals.Verify(concatWithPipeline);
// begin-snippet: ConcatWith_inputs
var concat = new List <int> {
1, 2
};
var with = new[] { 3, 4 };
// end-snippet
// begin-snippet: ConcatWith_outputs
var result = "[1, 2, 3, 4]";
// end-snippet
var manualConcatWith =
// begin-snippet: ConcatWith_manual
part1.JoinTo(part2).ProcessFunction(t => t.Item1.Concat(t.Item2).ToList());
// end-snippet
var manualConcatWithResult = manualConcatWith.Collect();
part1.Send(concat);
part2.Send(with);
Assert.AreEqual(result, collector.SingleResult.ToReadableString());
Assert.AreEqual(
manualConcatWithResult.SingleResult.ToReadableString(),
collector.SingleResult.ToReadableString());
}
public void ApplyTo()
{
var prefix = new InputPipe <string>("prefix");
var values = new InputPipe <int[]>("values");
var applyToPipeline = prefix.ApplyTo(values);
var collector = applyToPipeline.Collect();
PipelineApprovals.Verify(applyToPipeline);
// begin-snippet: ApplyTo_inputs
var apply = "#";
var to = new[] { 1, 2 };
// end-snippet
// begin-snippet: ApplyTo_outputs
var result = "[(#, 1), (#, 2)]";
// end-snippet
var manualApplyTo =
// begin-snippet: ApplyTo_manual
prefix.JoinTo(values).ProcessFunction(t => t.Item2.Select(i => Tuple.Create(t.Item1, i)));
// end-snippet
var manualApplyToResult = manualApplyTo.Collect();
prefix.Send(apply);
values.Send(to);
Assert.AreEqual(result, collector.SingleResult.ToReadableString());
Assert.AreEqual(
manualApplyToResult.SingleResult.ToReadableString(),
collector.SingleResult.ToReadableString());
}
public void MultipleBranchesPipe()
{
var input1 = new InputPipe <int>("input1");
var input2 = new InputPipe <int>("input2");
var joinedPipes = input1.JoinTo(input2);
var sumCollector = joinedPipes.Process((a, b) => a + b).Collect();
var productCollector = joinedPipes.Process((a, b) => a * b).Collect();
var inputsAndOutputs = joinedPipes.GetInputs <int, int>().AndOutputs <int, int>();
inputsAndOutputs.Send(3, 4);
var(in1, in2, sum, product) = inputsAndOutputs.AsTuple();
Assert.AreEqual(7, sum.SingleResult);
Assert.AreEqual(12, product.SingleResult);
var(in1_, in2_) = inputsAndOutputs.Inputs;
Assert.AreEqual(in1_, in1);
Assert.AreEqual(in2_, in2);
var(out1_, out2_) = inputsAndOutputs.Outputs;
Assert.AreEqual(out1_, sum);
Assert.AreEqual(out2_, product);
}
public void LambdaWithProcessFunction_ShouldThrow()
{
var input = new InputPipe <int>("input");
var exception = ExceptionUtilities.GetException(() => input.ProcessFunction(p => p.ToString()));
Approvals.VerifyException(exception);
}
public void CannotFindNodeExceptionHelpMessage()
{
var input1 = new InputPipe <long>("value1");
var subject = new NodeMetadata.CannotFindNodeException(input1);
Approvals.Verify(subject);
}
private static InputPipe <string> CreateQuickPipelineWithInput()
{
var input = new InputPipe <string>("age");
var parse = input.ProcessFunction(long.Parse);
parse.Collect();
return(input);
}
public void SplitInput()
{
var input = new InputPipe <long>("value");
input.ProcessFunction(LongToString);
input.ProcessFunction(IncrementLong);
PipelineApprovals.Verify(input);
}
public void InputsAndOutputs()
{
var inputPipe = new InputPipe <int>("input1");
var collectorPipe = inputPipe.Collect();
var subject = inputPipe.GetInputs <int>().AndOutputs <int>();
Assert.AreEqual(inputPipe, subject.Input1);
Assert.AreEqual(collectorPipe, subject.Output1);
}
public void SplitInput()
{
var input = new InputPipe <long>("value");
input.Process(LongToString);
input.Process(IncrementLong);
Verify(input);
}
public void Cast()
{
var input = new InputPipe <Animal>("animal");
var dog = input.Cast <Dog>();
var collector = dog.Process(d => d.IsGoodBoy).Collect();
input.Send(new Dog());
Assert.IsTrue(collector.SingleResult);
PipelineApprovals.Verify(input);
}
public void Lambda()
{
// begin-snippet: process_lambda
var input = new InputPipe <int>("input");
input.Process(p => p.ToString());
// end-snippet
PipelineApprovals.Verify(input);
}
public void BasicPipelineTest()
{
var input = new InputPipe <string>("age");
var parse = input.ProcessFunction(long.Parse);
var collector = parse.Collect();
PipelineApprovals.Verify(input);
input.Send("42");
Assert.AreEqual(42, collector.SingleResult);
}
public void ProcessIsCovariant()
{
var input = new InputPipe <int>("i");
var intArrayPipe = input.ProcessFunction(RangeArray);
var iEnumerableIntPipe = intArrayPipe.ProcessFunction(SumEnumerable);
var collector = iEnumerableIntPipe.Collect();
input.Send(4);
Assert.AreEqual(10, collector.SingleResult);
}
public IEnumerable <string> Serialize()
{
yield return(AssemblyPath.NativePath);
yield return(InputPipe.ToString());
yield return(OutputPipe.ToString());
yield return(UserDataPath.ToString());
}
private IGraphNode CreateFizzBuzzPipeline()
{
var inputPipe = new InputPipe <int>("number");
var fizzPipe = inputPipe.ProcessFunction(FizzConverter);
var buzzPipe = inputPipe.ProcessFunction(BuzzConverter);
var joinedPipe = fizzPipe.JoinTo(buzzPipe).Process((a, b) => a + b);
var joinedPipe2 = joinedPipe.JoinTo(inputPipe).ProcessFunction(DefaultPipe);
joinedPipe2.Collect();
return(inputPipe);
}
public void JoinInputsSample()
{
// begin-snippet: joined_pipeline
var input1 = new InputPipe <long>("value1");
var input2 = new InputPipe <long>("value2");
var join = input1.JoinTo(input2);
// end-snippet
PipelineApprovals.Verify(join);
}
public void ProcessIsNotCovariant()
{
var input = new InputPipe <int>("i");
var collector = input.ProcessFunction(RangeArray)
.ProcessFunction(_ => (IEnumerable <int>)_) // Would be nice not to need this
.ProcessFunction(SumEnumerable)
.Collect();
input.Send(4);
Assert.AreEqual(10, collector.SingleResult);
}
public void SplitInput()
{
// begin-snippet: graphviz_approval
var input = new InputPipe <long>("value");
input.ProcessFunction(LongToString);
input.ProcessFunction(IncrementLong);
PipelineApprovals.Verify(input);
// end-snippet
}
public void SplitAndJoin()
{
var input = new InputPipe <string>("age");
var parse = input.ProcessFunction(long.Parse);
var longToString = parse.ProcessFunction(LongToString);
var incrementLong = parse.ProcessFunction(IncrementLong);
var joinedPipes = longToString.JoinTo(incrementLong).Collect();
PipelineApprovals.Verify(input);
}
public void ConnectedPipelinesTest()
{
var input = new InputPipe <string>("age");
var parsePipe = input.Process(long.Parse);
var collector = parsePipe.Collect();
parsePipe.Process(LongToString).WithCollector().Process(long.Parse).WithCollector().Process(LongToString)
.Collect();
Verify(input);
}
public void ForEach()
{
var part1 = new InputPipe <List <long> >("part1");
var collector = part1.ProcessForEach(IncrementLong).Collect();
part1.Send(new List <long> {
1, 2
});
Assert.AreEqual("[2, 3]", collector.SingleResult.ToReadableString());
PipelineApprovals.Verify(part1);
}
public void SendAll()
{
var input = new InputPipe <int>("input");
var middle = input.Process(p => p + 1);
var end = middle.Process(p => p.ToString()).Collect();
var inputsAndOutputs = middle.GetInputs <int>().AndOutputs <string>();
var(inputPipe, collectorPipe) = inputsAndOutputs.AsTuple();
inputsAndOutputs.SendAll(new[] { 1, 2, 3 });
Approvals.VerifyAll(inputsAndOutputs.Output1.Results, "");
}
private void button3_Click(object sender, EventArgs e)
{
int input = int.Parse(inputTextBox.Text);
var inputPipe = new InputPipe <int>("input");
var parsePipe = inputPipe.ProcessFunction(IncrementWithDelay);
var collector = parsePipe.Collect();
inputPipe.Send(input);
var output = collector.SingleResult;
outputTextBox.Text = output.ToString();
}
public void JoinInputs()
{
var input1 = new InputPipe <long>("value1");
var input2 = new InputPipe <long>("value2");
var join = input1.JoinTo(input2);
var collector = join.ProcessFunction(Echo).Collect();
input1.Send(42);
Assert.IsTrue(collector.IsEmpty);
input2.Send(99);
Assert.AreEqual("(42, 99)", collector.SingleResult.ToString());
PipelineApprovals.Verify(join);
}
public void MultipleParameters()
{
var input1 = new InputPipe <long>("value1");
var input2 = new InputPipe <long>("value2");
var join = input1.JoinTo(input2);
var collector = join.Process((a, b) => a + b).Collect();
input1.Send(3);
Assert.IsTrue(collector.IsEmpty);
input2.Send(4);
Assert.AreEqual(7, collector.SingleResult);
PipelineApprovals.Verify(join);
}
public void JoinInputs()
{
var input1 = new InputPipe <long>("value1");
var input2 = new InputPipe <long>("value2");
var join = input1.JoinTo(input2);
var collector = join.Collect();
input1.Send(42);
Assert.IsTrue(collector.IsEmpty);
input2.Send(99);
Assert.AreEqual("(42, 99)", collector.SingleResult.ToString());
// TODO:
//Verify(join);
}
public static string Convert(int i)
{
// Set up Pipeline
var inputpipe = new InputPipe <int>("number");
var pipe = inputpipe.Process(_ => _.ToString());
var methodCallCollector = pipe.Collect();
inputpipe.Send(i);
var variable = methodCallCollector.SingleResult;
// ApprovalPipeline
PipelineApprovals.Verify(inputpipe);
// Send thru pipeline
// Original code
return(i.ToString());
}
public void MultipleBranchesPipe()
{
var input1 = new InputPipe <int>("input1");
var input2 = new InputPipe <int>("input2");
var joinedPipes = input1.JoinTo(input2);
var sumCollector = joinedPipes.Process((a, b) => a + b).Collect();
var productCollector = joinedPipes.Process((a, b) => a * b).Collect();
var inputsAndOutputs = joinedPipes.GetInputsAndOutputs();
((InputPipe <int>)inputsAndOutputs.Inputs[0]).Send(3);
((InputPipe <int>)inputsAndOutputs.Inputs[1]).Send(4);
Assert.AreEqual(7, ((CollectorPipe <int>)inputsAndOutputs.Outputs[0]).SingleResult);
Assert.AreEqual(12, ((CollectorPipe <int>)inputsAndOutputs.Outputs[1]).SingleResult);
}
public void MultipleJoinedBranches()
{
var input1 = new InputPipe <int>("input1");
var numbers1 = input1.Process(i1 => i1);
var numbers2 = input1.Process(i2 => i2);
var joinedPipes = numbers1.JoinTo(numbers2);
var addPipe = joinedPipes.Process((a, b) => a + b);
var collector = addPipe.Collect();
AssertInputsAndOutputs(input1, input1, collector);
AssertInputsAndOutputs(numbers1, input1, collector);
AssertInputsAndOutputs(numbers2, input1, collector);
AssertInputsAndOutputs(joinedPipes, input1, collector);
AssertInputsAndOutputs(addPipe, input1, collector);
AssertInputsAndOutputs(collector, input1, collector);
}
public void SingleBranchPipe()
{
var input = new InputPipe <int>("input");
var middle = input.Process(p => p + 1);
var end = middle.Process(p => p.ToString()).Collect();
var inputsAndOutputs = middle.GetInputs <int>().AndOutputs <string>();
var(inputPipe, collectorPipe) = inputsAndOutputs.AsTuple();
Assert.AreEqual(input, inputPipe);
Assert.AreEqual(end, collectorPipe);
inputsAndOutputs.Send(1);
var singleResult = collectorPipe.SingleResult;
Assert.AreEqual("2", singleResult);
}
