public FlowTakeSpec(ITestOutputHelper helper) : base(helper)
        {
            var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
            Materializer = ActorMaterializer.Create(Sys, settings);

            MuteDeadLetters(typeof(OnNext), typeof(OnComplete), typeof(RequestMore));
        }

        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 FlowLogSpec(ITestOutputHelper helper) : base("akka.loglevel = DEBUG", helper)
        {
            var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 16);
            Materializer = ActorMaterializer.Create(Sys, settings);

            var p = CreateTestProbe();
            Sys.EventStream.Subscribe(p.Ref, typeof(object));
            LogProbe = p;
        }

 public FlowSplitAfterSpec(ITestOutputHelper helper) : base(helper)
 {
     var settings =
         ActorMaterializerSettings.Create(Sys)
             .WithInputBuffer(2, 2)
             .WithSubscriptionTimeoutSettings(
                 new StreamSubscriptionTimeoutSettings(
                     StreamSubscriptionTimeoutTerminationMode.CancelTermination, TimeSpan.FromSeconds(1)));
     Materializer = ActorMaterializer.Create(Sys, settings);
 }

        public FileSourceSpec(ITestOutputHelper helper) : base(Utils.UnboundedMailboxConfig, helper)
        {
            Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
            var settings = ActorMaterializerSettings.Create(Sys).WithDispatcher("akka.actor.default-dispatcher");
            _materializer = Sys.Materializer(settings);

            var sb = new StringBuilder(6000);
            foreach (var character in new[] { "a", "b", "c", "d", "e", "f" })
                for (var i = 0; i < 1000; i++)
                    sb.Append(character);

            _testText = sb.ToString();
        }

        public FileSinkSpec(ITestOutputHelper helper) : base(Utils.UnboundedMailboxConfig, helper)
        {
            Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
            var settings = ActorMaterializerSettings.Create(Sys).WithDispatcher("akka.actor.default-dispatcher");
            _materializer = Sys.Materializer(settings);

            foreach (var character in new[] { "a", "b", "c", "d", "e", "f" })
            {
                var line = "";
                for (var i = 0; i < 1000; i++)
                    line += character;
                // don't use Environment.NewLine - it can contain more than one byte length marker, 
                // causing tests to fail due to incorrect number of bytes in input string
                line += "\n";
                _testLines.Add(line);
            }

            _testByteStrings = _testLines.Select(ByteString.FromString).ToList();
        }

        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 BidiFlowSpec()
 {
     var settings = ActorMaterializerSettings.Create(Sys);
     Materializer = ActorMaterializer.Create(Sys, settings);
 }

 public TickSourceSpec()
 {
     var settings = ActorMaterializerSettings.Create(Sys);
     Materializer = ActorMaterializer.Create(Sys, settings);
 }

 public GraphBalanceSpec()
 {
     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 FlowSupervisionSpec(ITestOutputHelper helper) : base(helper)
 {
     Materializer = ActorMaterializer.Create(Sys);
 }

 public OutputStreamSinkSpec(ITestOutputHelper helper) : base(Utils.UnboundedMailboxConfig, helper)
 {
     Sys.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
     var settings = ActorMaterializerSettings.Create(Sys).WithDispatcher("akka.actor.default-dispatcher");
     _materializer = Sys.Materializer(settings);
 }

 public PublisherSinkSpec(ITestOutputHelper helper) : base(helper)
 {
     var settings = ActorMaterializerSettings.Create(Sys);
     Materializer = ActorMaterializer.Create(Sys, settings);
 }

 public FlowSelectAsyncUnorderedSpec(ITestOutputHelper helper) : base(helper)
 {
     Materializer = ActorMaterializer.Create(Sys);
 }

 public FlowGroupedWithinSpec(ITestOutputHelper helper) : base(helper)
 {
     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 TimeoutsSpec(ITestOutputHelper helper = null) : base(helper)
 {
     Materializer = ActorMaterializer.Create(Sys);
 }

 public SubstreamSubscriptionTimeoutSpec(ITestOutputHelper helper) : base(Config, helper)
 {
     var settings = ActorMaterializerSettings.Create(Sys).WithInputBuffer(2, 2);
     Materializer = ActorMaterializer.Create(Sys, settings);
 }