public RemoteMigrationsFacts(ITestOutputHelper logHelper)
 {
     _logHelper = logHelper;
     _mockLogger = new MockLogger(logHelper);
     _migrator = new EfMigrator(PostgresFactConstants.DdlPath, PostgresFactConstants.ConfigName, PostgresFactConstants.AppConfig,
         PostgresFactConstants.InstanceConnectionString, PostgresFactConstants.ConnectionProvider, _mockLogger);
 }

 public CuratedFeedTest(ITestOutputHelper testOutputHelper)
     : base(testOutputHelper)
 {
     _commandlineHelper = new CommandlineHelper(TestOutputHelper);
     _clientSdkHelper = new ClientSdkHelper(TestOutputHelper);
     _packageCreationHelper = new PackageCreationHelper(TestOutputHelper);
 }

		public JsonRpcIntegrationTestBase(ITestOutputHelper output) {
			this.output = output;

			var configs = new JsonRpcServerConfigurations() {
				BindingPort = port, //Interlocked.Increment(ref port),
				TransportProtocol = JsonRpcServerConfigurations.TransportMode.Bson
			};

			server = new JsonRpcServer<TestActionHandler>(configs);

			client = JsonRpcClient<TestActionHandler>.CreateClient("localhost", server.Configurations.BindingPort, JsonRpcServerConfigurations.TransportMode.Bson);
			client.Info.Username = "TestUser";

			client.OnAuthenticationRequest += (sender, e) => {
				e.Data = AUTH_TEXT;
			};

			server.OnAuthenticationVerification += (sender, e) => {
				e.Authenticated = true;
			};

			server.OnStop += (sender, e) => {
				wait.Set();
			};
		}

        public static Output Ignore(ITestOutputHelper testOutputHelper)
        {
            if (ignore == null)
                ignore = new Output(testOutputHelper, "Ignore");

            return ignore;
        }

        public SendPacketsAsync(ITestOutputHelper output)
        {
            _log = TestLogging.GetInstance();

            byte[] buffer = new byte[s_testFileSize];

            for (int i = 0; i < s_testFileSize; i++)
            {
                buffer[i] = (byte)(i % 255);
            }

            try
            {
                _log.WriteLine("Creating file {0} with size: {1}", TestFileName, s_testFileSize);
                using (FileStream fs = new FileStream(TestFileName, FileMode.CreateNew))
                {
                    fs.Write(buffer, 0, buffer.Length);
                }
            }
            catch (IOException)
            {
                // Test payload file already exists.
                _log.WriteLine("Payload file exists: {0}", TestFileName);
            }
        }

 /// <summary>
 /// Executes package restore and builds the test solution.
 /// </summary>
 /// <param name="scenarioName">The name of the scenario to build. If omitted, it will be the name of the calling method.</param>
 /// <param name="packageId">The leaf name of the project to be built or rebuilt, and the package ID to return after the build.</param>
 /// <param name="properties">Build properties to pass to MSBuild.</param>
 /// <returns>The single built package, or the package whose ID matches <paramref name="packageId"/>.</returns>
 public static async Task<IPackage> RestoreAndBuildSinglePackageAsync([CallerMemberName] string scenarioName = null, string packageId = null, IDictionary<string, string> properties = null, ITestOutputHelper testLogger = null)
 {
     var packages = await RestoreAndBuildPackagesAsync(scenarioName, packageId, properties, testLogger);
     return packageId == null
             ? packages.Single()
             : packages.Single(p => string.Equals(p.Id, packageId, StringComparison.OrdinalIgnoreCase));
 }

 public OrleansTaskSchedulerAdvancedTests_Set2(ITestOutputHelper output)
 {
     this.output = output;
     OrleansTaskSchedulerBasicTests.InitSchedulerLogging();
     context = new UnitTestSchedulingContext();
     masterScheduler = TestInternalHelper.InitializeSchedulerForTesting(context);
 }

        public IntegrationTest(ITestOutputHelper writer)
        {
            if (File.Exists(output))
                File.Delete(output);

            this.writer = writer;
        }

        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 OutputLogger(ITestOutputHelper testOutputHelper)
        {
            if (testOutputHelper == null)
                throw new ArgumentNullException(nameof(testOutputHelper));

            this.testOutputHelper = testOutputHelper;
        }

 public NugetCommandLineTests(ITestOutputHelper testOutputHelper)
     : base(testOutputHelper)
 {
     _clientSdkHelper = new ClientSdkHelper(testOutputHelper);
     _commandlineHelper = new CommandlineHelper(testOutputHelper);
     _packageCreationHelper = new PackageCreationHelper(testOutputHelper);
 }

        /// <summary>
        /// Builds a project.
        /// </summary>
        /// <param name="projectPath">The absolute path to the project.</param>
        /// <param name="targetsToBuild">The targets to build. If not specified, the project's default target will be invoked.</param>
        /// <param name="properties">The optional global properties to pass to the project. May come from the <see cref="MSBuild.Properties"/> static class.</param>
        /// <returns>A task whose result is the result of the build.</returns>
        public static async Task<BuildResultAndLogs> ExecuteAsync(string projectPath, string[] targetsToBuild = null, IDictionary<string, string> properties = null, ITestOutputHelper testLogger = null)
        {
            targetsToBuild = targetsToBuild ?? new string[0];

            var logger = new EventLogger();
            var logLines = new List<string>();
            var parameters = new BuildParameters
            {
                Loggers = new List<ILogger>
                {
                    new ConsoleLogger(LoggerVerbosity.Detailed, logLines.Add, null, null),
                    new ConsoleLogger(LoggerVerbosity.Minimal, v => testLogger?.WriteLine(v.TrimEnd()), null, null),
                    logger,
                },
            };

            BuildResult result;
            using (var buildManager = new BuildManager())
            {
                buildManager.BeginBuild(parameters);
                try
                {
                    var requestData = new BuildRequestData(projectPath, properties ?? Properties.Default, null, targetsToBuild, null);
                    var submission = buildManager.PendBuildRequest(requestData);
                    result = await submission.ExecuteAsync();
                }
                finally
                {
                    buildManager.EndBuild();
                }
            }

            return new BuildResultAndLogs(result, logger.LogEvents, logLines);
        }

        public CXsltSettings(ITestOutputHelper output) : base(output)
        {
            // Make sure that we don't cache the value of the switch to enable testing
            AppContext.SetSwitch("TestSwitch.LocalAppContext.DisableCaching", true);

            _output = output;
        }

        public MigratorFacts(ITestOutputHelper logHelper)
        {
            _logHelper = logHelper;
            _mockLogger = new MockLogger(logHelper);

            _logHelper.WriteLine($"Using connectionString: {_instanceString}");
        }

        public BulkheadSpecsHelper(ITestOutputHelper testOutputHelper)
        {
#if !DEBUG 
            testOutputHelper = new SilentOutput();
#endif
            this.testOutputHelper = testOutputHelper;
        }

 protected PersistenceSpec(Config config = null, ITestOutputHelper output = null)
     : base(config, output)
 {
     _name = NamePrefix + "-" + _counter.GetAndIncrement();
     Clean = new Cleanup(this);
     Clean.Initialize();
 }

        public TaskAppServiceTests(ITestOutputHelper output)
        {
            this.output = output;

            this._taskAppService = Resolve<ITaskAppService>();
            this._userAppService = Resolve<ITaskeverUserAppService>();
        }

 public CSharpExampleFileTests(ITestOutputHelper output)
 {
     _output = output;
     var subject = new CSharpLexer();
     _results = subject.GetTokens(SampleFile.Load("csharp-sample.txt"))
         .ToArray();
 }

        public HarvestPackageTests(ITestOutputHelper output)
        {
            _log = new Log(output);
            _engine = new TestBuildEngine(_log);

            _frameworks = new[]
            {
                CreateFrameworkItem("netcoreapp1.0", "win7-x86;win7-x64;osx.10.11-x64;centos.7-x64;debian.8-x64;linuxmint.17-x64;opensuse.13.2-x64;rhel.7.2-x64;ubuntu.14.04-x64;ubuntu.16.04-x64"),
                CreateFrameworkItem("netcoreapp1.1", "win7-x86;win7-x64;osx.10.11-x64;centos.7-x64;debian.8-x64;linuxmint.17-x64;opensuse.13.2-x64;rhel.7.2-x64;ubuntu.14.04-x64;ubuntu.16.04-x64"),

                CreateFrameworkItem("netcore50", "win10-x86;win10-x86-aot;win10-x64;win10-x64-aot;win10-arm;win10-arm-aot"),
                CreateFrameworkItem("netcore45", ""),
                CreateFrameworkItem("netcore451", ""),

                CreateFrameworkItem("net45", ";win-x86;win-x64"),
                CreateFrameworkItem("net451", ";win-x86;win-x64"),
                CreateFrameworkItem("net46", ";win-x86;win-x64;win7-x86;win7-x64"),
                CreateFrameworkItem("net461", ";win-x86;win-x64;win7-x86;win7-x64"),
                CreateFrameworkItem("net462", ";win-x86;win-x64;win7-x86;win7-x64"),
                CreateFrameworkItem("net463", ";win-x86;win-x64;win7-x86;win7-x64"),

                CreateFrameworkItem("wpa81", ""),
                CreateFrameworkItem("wp8", ""),
                CreateFrameworkItem("MonoAndroid10", ""),
                CreateFrameworkItem("MonoTouch10", ""),
                CreateFrameworkItem("xamarinios10", ""),
                CreateFrameworkItem("xamarinmac20", ""),
                CreateFrameworkItem("xamarintvos10", ""),
                CreateFrameworkItem("xamarinwatchos10", "")
            };
        }

 public XunitTestLogger(ITestOutputHelper outputHelper, Config config) : base(entry =>
 {
     if (config.Verbose || entry.Severity != Severity.Debug)
         LogEntryWriter.Write(entry, outputHelper);
 })
 {
 }