/// <summary> /// Creates the coverage report from the xml coverage files spécified. /// </summary> /// <param name="sources">The sources XML files.</param> /// <param name="destination">The destination directory.</param> /// <param name="logger">The logger.</param> public static void CreateReport(IList <string> sources, string destination, ILogger logger) { if (logger == null) { throw new ArgumentNullException("logger"); } if (sources == null || sources.Count == 0) { return; } if (String.IsNullOrEmpty(destination)) { throw new ArgumentException("Destination must be a valid path.", "destination"); } if (Directory.Exists(destination)) { Directory.Delete(destination, true); } ProcessTask mergeTask = CreateMergeTask(sources, destination); logger.Log(LogSeverity.Info, string.Format("Genrating {0} coverage report to '{1}': \"{2}\" {3}", Name, destination, mergeTask.ExecutablePath, mergeTask.Arguments)); mergeTask.CaptureConsoleOutput = true; mergeTask.ConsoleOutputDataReceived += (sender, e) => { if (e.Data != null) { logger.Log(LogSeverity.Info, e.Data); } }; mergeTask.CaptureConsoleError = true; mergeTask.ConsoleErrorDataReceived += (sender, e) => { if (e.Data != null) { logger.Log(LogSeverity.Error, e.Data); } }; if (!mergeTask.Run(null)) { throw new PartCoverToolException(string.Format("Failed to generate {0} coverage report. The report command failed with exit code {1}.", Name, mergeTask.ExitCode)); } int i = 0; foreach (string source in sources) { if (!string.IsNullOrEmpty(source) && File.Exists(source)) { i++; File.Move(source, Path.Combine(destination, String.Format("coverage_{0:D4}.xml", i))); } } }
public void EchoDoesNotTerminateAbruptlyOnUnhandledExceptions() { ProcessTask task = RunEcho("/ignore-annotations /filter:Type:UnhandledExceptionTest"); Assert.Contains(task.ConsoleOutput, "2 run, 2 passed, 0 failed, 0 inconclusive, 0 skipped"); Assert.Contains(task.ConsoleOutput, "Unhandled!"); Assert.AreEqual(0, task.ExitCode, "Exit code should be zero because the unhandled exception test still passes."); }
public void CacheProvider_NoPipeline() { var pt1 = new ProcessTask(CatalogueRepository, _lmd, LoadStage.GetFiles); pt1.Path = typeof(TestCachedFileRetriever).FullName; pt1.ProcessTaskType = ProcessTaskType.DataProvider; pt1.Name = "Cache1"; pt1.SaveToDatabase(); _cp.CacheFillProgress = new DateTime(1999, 1, 1); _cp.Name = "MyTestCp"; _cp.SaveToDatabase(); pt1.CreateArgumentsForClassIfNotExists <TestCachedFileRetriever>(); var projDir = LoadDirectory.CreateDirectoryStructure(new DirectoryInfo(TestContext.CurrentContext.TestDirectory), "delme", true); _lmd.LocationOfFlatFiles = projDir.RootPath.FullName; _lmd.SaveToDatabase(); try { var ex = Assert.Throws <Exception>(() => _factory.Create(_lp, new ThrowImmediatelyDataLoadEventListener())); Assert.AreEqual("CacheProgress MyTestCp does not have a Pipeline configured on it", ex.Message); } finally { projDir.RootPath.Delete(true); } }
/// <summary> /// Run the application. /// </summary> public void Run() { Privilege.IsAdmin(); if (Privilege.IsAdmin() == false) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { try { Privilege.RelaunchAsAdmin(""); } catch (Exception ex) { ConsoleStyle.ErrorMessage(ex.Message); Environment.Exit(5); } } else { ConsoleStyle.ErrorMessage("Administrator privileges are required!"); Environment.Exit(403); } } // display program header. ConsoleStyle.ProgramHeader(); // start to kill php processes. var processTask = new ProcessTask(); processTask.killPHP(); // success message and exit. ConsoleStyle.SuccessExit(); }
/// <summary> /// Starts a new process and begins watching it. /// </summary> /// <remarks> /// <para> /// The output of the process will be logged and included as part of the test results. It /// may also be examined using the <see cref="ProcessTask.ConsoleOutput" /> and /// <see cref="ProcessTask.ConsoleError" /> properties while the process executes and /// after it terminates. /// </para> /// <para> /// There is no need to call <see cref="WatchTask" /> on the returned task. /// </para> /// </remarks> /// <param name="executablePath">The path of the executable executable.</param> /// <param name="arguments">The arguments for the executable.</param> /// <param name="workingDirectory">The working directory.</param> /// <returns>The new thread task.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="executablePath"/>, /// <paramref name="arguments"/> or <paramref name="workingDirectory"/> is null.</exception> public static ProcessTask StartProcessTask(string executablePath, string arguments, string workingDirectory) { ProcessTask task = CreateProcessTask(executablePath, arguments, workingDirectory); task.Start(); return(task); }
private static ProcessTask RunMSTest(string options) { string value = (string)RegistryUtils.GetValueWithBitness( ProcessorArchitecture.X86, RegistryHive.LocalMachine, @"Software\Microsoft\VisualStudio\9.0", "InstallDir", null); if (value == null) { Assert.Inconclusive("Visual Studio 2008 does not appear to be installed."); } string executablePath = Path.Combine(value, "MSTest.exe"); if (!File.Exists(executablePath)) { Assert.Inconclusive("Visual Studio 2008 appears to be installed but MSTest.exe was not found."); } string testAssemblyPath = AssemblyUtils.GetAssemblyLocalPath(typeof(SimpleTest).Assembly); string workingDirectory = Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(typeof(GallioTipIntegrationTest).Assembly)); ProcessTask task = Tasks.StartProcessTask(executablePath, "\"/testcontainer:" + testAssemblyPath + "\" " + options, workingDirectory); Assert.IsTrue(task.Run(TimeSpan.FromSeconds(60)), "A timeout occurred."); return(task); }
/// <inheritdoc /> public IVisualStudio LaunchVisualStudio(VisualStudioVersion version, ILogger logger) { if (logger == null) { throw new ArgumentNullException("logger"); } Pair <string, VisualStudioVersion>?installDirAndVersion = GetVisualStudioInstallDirAndVersion(version); if (!installDirAndVersion.HasValue) { logger.Log(LogSeverity.Debug, string.Format("Could not find Visual Studio version '{0}'.", version)); return(null); } string devenvPath = Path.Combine(installDirAndVersion.Value.First, "devenv.exe"); ProcessTask devenvProcessTask = new ProcessTask(devenvPath, "", Environment.CurrentDirectory); logger.Log(LogSeverity.Debug, string.Format("Launching Visual Studio using path: '{0}'.", devenvProcessTask.ExecutablePath)); devenvProcessTask.Start(); System.Diagnostics.Process devenvProcess = devenvProcessTask.Process; if (devenvProcess != null) { int processId = devenvProcess.Id; Stopwatch stopwatch = Stopwatch.StartNew(); for (;;) { IVisualStudio visualStudio = GetVisualStudioFromProcess(processId, installDirAndVersion.Value.Second, true, logger); if (visualStudio != null) { return(visualStudio); } if (stopwatch.ElapsedMilliseconds > VisualStudioAttachTimeoutMilliseconds) { logger.Log(LogSeverity.Debug, string.Format("Stopped waiting for Visual Studio to launch after {0} milliseconds.", VisualStudioAttachTimeoutMilliseconds)); break; } if (!devenvProcessTask.IsRunning) { break; } Thread.Sleep(500); } } if (devenvProcessTask.IsTerminated && devenvProcessTask.Result != null) { if (!devenvProcessTask.Result.HasValue) { logger.Log(LogSeverity.Debug, "Failed to launch Visual Studio.", devenvProcessTask.Result.Exception); } } return(null); }
public void EchoPrintsCorrectOutputForPassingAndFailingTestsAndReturnsAnExitCodeOfOne() { ProcessTask task = RunEcho("/ignore-annotations /filter:Type:SimpleTest"); Assert.Contains(task.ConsoleOutput, "2 run, 1 passed, 1 failed, 0 inconclusive, 0 skipped"); Assert.AreEqual(1, task.ExitCode, "Exit code for failing tests should be one."); }
public GitInstallationState ValidateGitLfsVersion(GitInstallationState state) { // default installation doesn't have a standalone "git-lfs" exe if (state.GitInstallationPath == installDetails.GitInstallationPath) { state.GitLfsIsValid = true; state.GitLfsVersion = state.GitVersion; return(state); } if (!state.GitLfsExecutablePath.IsInitialized || !state.GitLfsExecutablePath.FileExists()) { state.GitLfsIsValid = false; return(state); } var version = new ProcessTask <TheVersion>(Token, state.GitLfsExecutablePath, "version", new LfsVersionOutputProcessor()) .Configure(processManager) .Progress(progressReporter.UpdateProgress) .Catch(e => true) .RunSynchronously(); state.GitLfsIsValid = version >= Constants.MinimumGitLfsVersion; state.GitLfsVersion = version; return(state); }
public void CreateTask() { _lmd = new LoadMetadata(CatalogueRepository); _dir = new DirectoryInfo(Path.Combine(TestContext.CurrentContext.TestDirectory, "ProcessTaskCheckingTests")); _dir.Create(); var hicdir = LoadDirectory.CreateDirectoryStructure(_dir, "ProjDir", true); _lmd.LocationOfFlatFiles = hicdir.RootPath.FullName; _lmd.SaveToDatabase(); Catalogue c = new Catalogue(CatalogueRepository, "c"); CatalogueItem ci = new CatalogueItem(CatalogueRepository, c, "ci"); TableInfo t = new TableInfo(CatalogueRepository, "t"); t.Server = DiscoveredServerICanCreateRandomDatabasesAndTablesOn.Name; t.Database = "mydb"; t.SaveToDatabase(); ColumnInfo col = new ColumnInfo(CatalogueRepository, "col", "bit", t); ci.SetColumnInfo(col); c.LoadMetadata_ID = _lmd.ID; c.SaveToDatabase(); _task = new ProcessTask(CatalogueRepository, _lmd, LoadStage.GetFiles); _checker = new ProcessTaskChecks(_lmd); }
public void StartLongRunningProcess(string id, int PaypalApi, string RangeDate) { longRunningClass.Add(id); ProcessTask processTask = new ProcessTask(longRunningClass.ProcessLongRunningAction); processTask.BeginInvoke(id, PaypalApi, RangeDate, new AsyncCallback(EndLongRunningProcess), processTask); }
public void CmdletPrintsCorrectOutputForPassingAndFailingTestsAndReturnsAResultCodeOfOne() { ProcessTask task = RunPowerShell("-verbose -filter Type:SimpleTest -ignore-annotations"); Assert.Contains(task.ConsoleOutput, "2 run, 1 passed, 1 failed, 0 inconclusive, 0 skipped"); Assert.Like(task.ConsoleOutput, "ResultCode *: 1"); }
public void OneTimeSetup() { Logging.LogAdapter = new ConsoleLogAdapter(); //Logging.TracingEnabled = true; TaskManager = new TaskManager(); var syncContext = new ThreadSynchronizationContext(Token); TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(syncContext); var env = new DefaultEnvironment(); TestBasePath = NPath.CreateTempDirectory("integration-tests"); env.FileSystem.SetCurrentDirectory(TestBasePath); var repo = Substitute.For <IRepository>(); repo.LocalPath.Returns(TestBasePath); env.Repository = repo; var platform = new Platform(env); ProcessManager = new ProcessManager(env, platform.GitEnvironment, Token); var processEnv = platform.GitEnvironment; var path = new ProcessTask <NPath>(TaskManager.Token, new FirstLineIsPathOutputProcessor()) .Configure(ProcessManager, env.IsWindows ? "where" : "which", "git") .Start().Result; env.GitExecutablePath = path ?? "git".ToNPath(); }
/// <summary> /// Creates a <see cref="AnySeparatorFileAttacher"/> parcelled into a <see cref="ProcessTask"/> that reads CSV files in ForLoading /// in the mounting stage of the load /// </summary> /// <param name="lmd">The load to create the <see cref="ProcessTask"/> in</param> /// <param name="pattern">File pattern to load e.g. *.csv</param> /// <param name="ti">The table to load (must be part of the <paramref name="lmd"/></param> /// <param name="separator">The separator of the files e.g. ','</param> /// <param name="ignoreColumns">Columns to ignore in the load</param> /// <returns></returns> protected ProcessTask CreateFlatFileAttacher(LoadMetadata lmd, string pattern, ITableInfo ti, string separator = ",", string ignoreColumns = "hic_dataLoadRunID") { var csvProcessTask = new ProcessTask(CatalogueRepository, lmd, LoadStage.Mounting); var args = csvProcessTask.CreateArgumentsForClassIfNotExists <AnySeparatorFileAttacher>(); csvProcessTask.Path = typeof(AnySeparatorFileAttacher).FullName; csvProcessTask.ProcessTaskType = ProcessTaskType.Attacher; csvProcessTask.SaveToDatabase(); var filePattern = args.Single(a => a.Name == "FilePattern"); filePattern.SetValue(pattern); filePattern.SaveToDatabase(); var tableToLoad = args.Single(a => a.Name == "TableToLoad"); tableToLoad.SetValue(ti); tableToLoad.SaveToDatabase(); var separatorArg = args.Single(a => a.Name == "Separator"); separatorArg.SetValue(separator); separatorArg.SaveToDatabase(); var ignoreDataLoadRunIDCol = args.Single(a => a.Name == "IgnoreColumns"); ignoreDataLoadRunIDCol.SetValue(ignoreColumns); ignoreDataLoadRunIDCol.SaveToDatabase(); return(csvProcessTask); }
public async Task RunAsync_RaisesOutputEvent() { //Arrange using (var tempFile = new TemporaryFile("bat")) { var batchScript = @" @echo off ECHO TestOutput EXIT /B 0 "; File.WriteAllText(tempFile.FileName, batchScript); var processTask = new ProcessTask(tempFile.FileName, cancellationToken); processTask.OutputReceived += (sender, args) => { var e = args as DataReceivedEventArgs; Assert.IsNotNull(e); if (e.Data != null) { Assert.AreEqual("TestOutput", e.Data); } }; //Act var result = await processTask.RunAsync(); //Assert Assert.AreEqual(0, result); } }
public void EchoPrintsCorrectOutputForPassingTestsAndReturnsAnExitCodeOfZero() { ProcessTask task = RunEcho("/ignore-annotations /filter:Type:PassingTests"); Assert.Contains(task.ConsoleOutput, "2 run, 2 passed, 0 failed, 0 inconclusive, 0 skipped"); Assert.AreEqual(0, task.ExitCode, "Exit code for passing tests should be zero."); }
public async Task RunAsync_CallsGlobalApplication() { //Arrange var outputWritten = false; var startInfo = new ProcessStartInfo() { FileName = "dir", WindowStyle = ProcessWindowStyle.Hidden, UseShellExecute = false, RedirectStandardError = true, RedirectStandardOutput = true, CreateNoWindow = false, }; var processTask = new ProcessTask(startInfo, cancellationToken); processTask.OutputReceived += (sender, args) => { var e = args as DataReceivedEventArgs; Assert.IsNotNull(e); if (e.Data != null) { outputWritten = true; } Console.WriteLine(e.Data); }; //Act var result = await processTask.RunAsync(); //Assert Assert.AreEqual(0, result); Assert.IsTrue(outputWritten); }
public void TaskSupportsCustomExtensions() { ProcessTask task = RunNAnt("Extensions"); Assert.Contains(task.ConsoleOutput, "TestStepStarted"); // text appears in the debug output Assert.AreEqual(0, task.ExitCode); }
private void AddMenu <T>(string menuName, Func <Type, bool> filterTypes) { var types = _mef.GetTypes <T>().Where(filterTypes).ToArray(); var menu = new ToolStripMenuItem(menuName); ProcessTaskType taskType; if (typeof(T) == typeof(IDataProvider)) { taskType = ProcessTaskType.DataProvider; } else if (typeof(T) == typeof(IAttacher)) { taskType = ProcessTaskType.Attacher; } else if (typeof(T) == typeof(IMutilateDataTables)) { taskType = ProcessTaskType.MutilateDataTable; } else { throw new ArgumentException("Type '" + typeof(T) + "' was not expected", "T"); } foreach (Type type in types) { Type toAdd = type; menu.DropDownItems.Add(type.Name, null, (s, e) => AddTypeIntoStage(toAdd, taskType)); } menu.Enabled = ProcessTask.IsCompatibleStage(taskType, _loadStageNode.LoadStage) && types.Any(); Items.Add(menu); }
public override void Execute() { if (_type == null) { if (BasicActivator.SelectType("Process Type", GetProcessTaskTypes(), out Type chosen)) { SetType(chosen); } else { return; } } ProcessTask newTask = new ProcessTask(BasicActivator.RepositoryLocator.CatalogueRepository, _loadMetadata, _loadStage); newTask.Path = _type.FullName; newTask.ProcessTaskType = _processTaskType; newTask.Name = _type.Name; newTask.SaveToDatabase(); newTask.CreateArgumentsForClassIfNotExists(_type); Publish(_loadMetadata); Activate(newTask); }
public void AmbienceServerRunsWithSpecifiedOptions() { File.Delete("IntegrationTest.db"); ProcessTask task = StartAmbienceServer("/db:IntegrationTest.db /p:" + PortNumber + " /u:Test /pw:LetMeIn"); var config = new AmbienceClientConfiguration() { Port = PortNumber, Credential = new NetworkCredential("Test", "LetMeIn") }; AmbienceClient client = AmbienceClient.Connect(config); IAmbientDataContainer container = client.Container; container.DeleteAll(); container.Store(new Item() { Name = "foo", Value = 42 }); container.Store(new Item() { Name = "bar", Value = 40 }); Assert.AreEqual("foo", (from Item x in container where x.Value == 42 select x.Name).Single()); Assert.AreEqual(0, (from Item x in container where x.Value == 0 select x).Count()); task.Abort(); }
protected override void SetBindings(BinderWithErrorProviderFactory rules, ProcessTask databaseObject) { base.SetBindings(rules, databaseObject); Bind(tbName, "Text", "Name", d => d.Name); Bind(tbID, "Text", "ID", d => d.ID); }
/// <summary> /// Ends the long running process. /// </summary> /// <param name="result">The result.</param> public void EndLongRunningProcess(IAsyncResult result) { ProcessTask processTask = (ProcessTask)result.AsyncState; string id = processTask.EndInvoke(result); longRunningClass.Remove(id); }
public void CacheProvider_NoCacheProgress() { var pt1 = new ProcessTask(CatalogueRepository, _lmd, LoadStage.GetFiles); pt1.Path = typeof(BasicCacheDataProvider).FullName; pt1.ProcessTaskType = ProcessTaskType.DataProvider; pt1.Name = "Cache1"; pt1.SaveToDatabase(); var projDir = LoadDirectory.CreateDirectoryStructure(new DirectoryInfo(TestContext.CurrentContext.TestDirectory), "delme", true); _lmd.LocationOfFlatFiles = projDir.RootPath.FullName; _lmd.SaveToDatabase(); var pipeAssembler = new TestDataPipelineAssembler("CacheProvider_Normal", CatalogueRepository); pipeAssembler.ConfigureCacheProgressToUseThePipeline(_cp); try { var ex = Assert.Throws <InvalidOperationException>(() => _factory.Create(_lp, new ThrowImmediatelyDataLoadEventListener())); Assert.AreEqual("Caching has not begun for this CacheProgress (" + _cp.ID + "), so there is nothing to load and this strategy should not be used.", ex.Message); } finally { _cp.Pipeline_ID = null; pipeAssembler.Destroy(); projDir.RootPath.Delete(true); } }
private static void tryDispatch(string tag) { lock (endequeueCS) { if (!queues.ContainsKey(tag) || queues[tag].Count == 0) { return; } if (runningTask.ContainsKey(tag) && !runningTask[tag].task.IsCompleted) { return; } var taskInfo = queues[tag].First.Value; queues[tag].RemoveFirst(); var cts = new CancellationTokenSource(); var newTask = new ProcessTask { queueid = taskInfo.queueid, cancelable = taskInfo.cancelable, task = Task.Run(() => { taskInfo.task(); tryDispatch(tag); }, cts.Token), cts = cts }; runningTask[tag] = newTask; } }
public int InitializeProcess(int id) { Guid processGuid = _context.Processes.Where(p => p.Id == id).FirstOrDefault().ProcessGuid; ProcessTask ptStarter = new ProcessTask(); ptStarter.ProcessTaskGuid = Guid.NewGuid(); ptStarter.ProcessGuid = processGuid; ptStarter.TaskName = "Process Start"; ptStarter.TaskTypeId = 5; ptStarter.CreatedDate = DateTime.Now; ptStarter.CompletionTask = 1; ptStarter.DeletedDate = null; ProcessTask ptEnder = new ProcessTask(); ptEnder.ProcessTaskGuid = Guid.NewGuid(); ptEnder.ProcessGuid = processGuid; ptEnder.TaskName = "Process End"; ptEnder.TaskTypeId = 6; ptEnder.CreatedDate = DateTime.Now; ptEnder.CompletionTask = 1; ptEnder.DeletedDate = null; _context.ProcessTasks.Add(ptStarter); _context.ProcessTasks.Add(ptEnder); _context.SaveChanges(); return(id); }
public ExecuteCommandCreateNewProcessTask(IActivateItems activator, ProcessTaskType taskType, LoadMetadata loadMetadata, LoadStage loadStage, FileInfo file = null) : base(activator) { _taskType = taskType; _loadMetadata = loadMetadata; _loadStage = loadStage; try { _LoadDirectory = new LoadDirectory(_loadMetadata.LocationOfFlatFiles); } catch (Exception) { SetImpossible("Could not construct LoadDirectory"); } if (taskType == ProcessTaskType.SQLFile) { _image = activator.CoreIconProvider.GetImage(RDMPConcept.SQL, OverlayKind.Add); } else if (taskType == ProcessTaskType.Executable) { _image = new IconOverlayProvider().GetOverlayNoCache(CatalogueIcons.Exe, OverlayKind.Add); } else { SetImpossible("Only SQLFile and Executable task types are supported by this command"); } if (!ProcessTask.IsCompatibleStage(taskType, loadStage)) { SetImpossible("You cannot run " + taskType + " in " + loadStage); } _file = file; }
public void OneTimeSetup() { GitHub.Unity.Guard.InUnitTestRunner = true; LogHelper.LogAdapter = new MultipleLogAdapter(new FileLogAdapter($"..\\{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}-tasksystem-tests.log")); //LogHelper.TracingEnabled = true; TaskManager = new TaskManager(); var syncContext = new ThreadSynchronizationContext(Token); TaskManager.UIScheduler = new SynchronizationContextTaskScheduler(syncContext); var env = new DefaultEnvironment(); TestBasePath = NPath.CreateTempDirectory("integration-tests"); env.FileSystem.SetCurrentDirectory(TestBasePath); var repo = Substitute.For <IRepository>(); repo.LocalPath.Returns(TestBasePath); env.Repository = repo; var platform = new Platform(env); ProcessManager = new ProcessManager(env, platform.GitEnvironment, Token); var processEnv = platform.GitEnvironment; var path = new ProcessTask <NPath>(TaskManager.Token, new FirstLineIsPathOutputProcessor()) .Configure(ProcessManager, env.IsWindows ? "where" : "which", "git") .Start().Result; env.GitExecutablePath = path.IsInitialized ? path : "git".ToNPath(); }
private void CreateAttacher(ITableInfo t, QueryBuilder qb, LoadMetadata lmd, LoadProgress loadProgressIfAny) { var pt = new ProcessTask(Activator.RepositoryLocator.CatalogueRepository, lmd, LoadStage.Mounting); pt.ProcessTaskType = ProcessTaskType.Attacher; pt.Name = "Read from " + t; pt.Path = typeof(RemoteTableAttacher).FullName; pt.SaveToDatabase(); pt.CreateArgumentsForClassIfNotExists <RemoteTableAttacher>(); pt.SetArgumentValue("RemoteServer", t.Server); pt.SetArgumentValue("RemoteDatabaseName", t.GetDatabaseRuntimeName(LoadStage.PostLoad)); pt.SetArgumentValue("RemoteTableName", t.GetRuntimeName()); pt.SetArgumentValue("DatabaseType", DatabaseType.MicrosoftSQLServer); pt.SetArgumentValue("RemoteSelectSQL", qb.SQL); pt.SetArgumentValue("RAWTableName", t.GetRuntimeName(LoadBubble.Raw)); if (loadProgressIfAny != null) { pt.SetArgumentValue("Progress", loadProgressIfAny); // pt.SetArgumentValue("ProgressUpdateStrategy", DataLoadProgressUpdateStrategy.UseMaxRequestedDay); pt.SetArgumentValue("LoadNotRequiredIfNoRowsRead", true); } /* * * public DataLoadProgressUpdateInfo { get; set; } */ }
public void EchoDoesNotShowLogoAndReturnsAnExitCodeOfZero() { ProcessTask task = RunEcho("/no-logo"); Assert.DoesNotContain(task.ConsoleOutput,"Gallio Echo - Version "); Assert.DoesNotContain(task.ConsoleOutput, "Get the latest version at http://www.gallio.org"); Assert.AreEqual(1, task.ExitCode, "Exit code with no tests should be one."); }
public void StartProcessing(string id) { this.Add(id); ProcessTask processTask = new ProcessTask(this.ProcessLongRunningAction); processTask.BeginInvoke(id, new AsyncCallback(this.EndLongRunningProcess), processTask); }