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.VerifyAsSvg(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).Process(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.VerifyAsSvg(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).Process(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 BasicPipelineTest()
        {
            var input     = new InputPipe <string>("age");
            var parse     = input.ProcessFunction(long.Parse);
            var collector = parse.Collect();

            PipelineApprovals.VerifyAsSvg(input);
            input.Send("42");
            Assert.AreEqual(42, collector.SingleResult);
        }
        public void Lambda()
        {
            // begin-snippet: process_lambda
            var input = new InputPipe <int>("input");

            input.Process(p => p.ToString());
            // end-snippet

            PipelineApprovals.VerifyAsSvg(input);
        }
        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.VerifyAsSvg(join);
        }
        public void TestSvg()
        {
            var input = CreateQuickPipelineWithInput();

            PipelineApprovals.VerifyAsSvg(input);
        }