/// <summary> /// /// </summary> /// <param name="timeMilliseconds">Время исполнения</param> /// <returns></returns> public override async Task <bool> Execute(int timeMilliseconds) { var result = false; await Task.Run(async() => { using (AppProcess) { InitExecute(); _monitor?.Start(); await Task.Delay(TaskDelay); if (IsStdInput) { foreach (var elem in _inputData) { Input = elem; } } result = AppProcess.WaitForExit(timeMilliseconds); _monitor?.Stop(); if (!(_monitor is null)) { _monitor.Time = -TaskDelay; } } }); return(result); }
public async Task TestProject_on_success_returns_status() { AppProcess unitTest = await _service.Test(_successfulTests, _successfulTests.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Assert.Equal(AppTask.Test, unitTest.Task); Assert.Equal(AppStatus.Success, unitTest.Status); }
/// <summary> /// UIの表示状態を変更 /// </summary> public void ChangeUI(bool isActive, AppProcess appProcess) { switch (appProcess) { case AppProcess.CreateAnchorMode: m_CreateAnchorModeButton.gameObject.SetActive(isActive); break; case AppProcess.ReproduceAnchorMode: m_ReproduceAnchorModeButton.gameObject.SetActive(isActive); break; case AppProcess.CreateAnchor: m_CreateAnchorButton.gameObject.SetActive(isActive); break; case AppProcess.AddAnchor: m_AddAnchorButton.gameObject.SetActive(isActive); break; case AppProcess.DeleteAnchor: m_DeleteAnchorButton.gameObject.SetActive(isActive); break; case AppProcess.TopMenu: m_TopMenuButton.gameObject.SetActive(isActive); break; } }
public async Task Build_will_build_every_project_for_given_framework() { var backend = SampleProjects.Backend; var frontend = SampleProjects.Frontend; var projects = new[] { backend, frontend }; var options = TestOptions.Create(); var backendDirectoryPaths = backend.GetAppDirectoryPaths(_fileSystem); var backendBuildProccess = new AppProcess(new Process(), AppTask.Build, AppStatus.Success); _dotnetServiceMock.Setup(m => m.Build(backend, backendDirectoryPaths[0], options, It.IsAny <CancellationToken>())) .ReturnsAsync(backendBuildProccess) .Verifiable(); var frontendDirectoryPaths = frontend.GetAppDirectoryPaths(_fileSystem); var frontendBuildProcess = new AppProcess(new Process(), AppTask.Build, AppStatus.Success); _nodeServiceMock.Setup(m => m.Build(frontend, frontendDirectoryPaths[0], options, It.IsAny <CancellationToken>())) .ReturnsAsync(frontendBuildProcess) .Verifiable(); var output = await _runnerService.BuildAsync(projects, options, CancellationToken.None); Assert.Same(backend, output[0]); Assert.Same(backendBuildProccess, output[0].Processes.First()); Assert.Same(frontend, output[1]); Assert.Same(frontendBuildProcess, output[1].Processes.First()); _dotnetServiceMock.Verify(); _nodeServiceMock.Verify(); }
/// <summary> /// Create a new instance of the application. /// </summary> /// <param name="item">The <see cref="Item"/> on which this instance is based on.</param> public ApplicationInstance(Item item) { Item = item; _resizeTimer = new Timer { AutoReset = false, Interval = 500 }; _resizeTimer.Elapsed += ResizeTimer_Elapsed; CloseCommand = new RelayCommand(o => { AppProcess.CloseMainWindow(); AppProcess.Close(); Dispose(); }); DetachCommand = new RelayCommand(o => { // Unset the parent Win32.SetParent(_windowHandle, IntPtr.Zero); // Reset the style Win32.SetWindowLongPtr(_windowHandle, Win32.GWL_STYLE, new IntPtr(_originalWindowStyle)); // Reset the position Win32.SetWindowPos(_windowHandle, IntPtr.Zero, _originalWindowRect.Left, _originalWindowRect.Top, _originalWindowRect.Width(), _originalWindowRect.Height(), Win32.SWP_NOZORDER | Win32.SWP_NOACTIVATE); Dispose(); }); }
public bool EmbedProcess(int width, int height) { OpenExternProcess(width, height); try { var pluginWinHandle = AppProcess.MainWindowHandle; //Get the handle of main window. embedResult = Win32API.SetParent(pluginWinHandle, _hostWinHandle); //set parent window Win32API.SetWindowLong(new HandleRef(this, pluginWinHandle), Win32API.GWL_STYLE, Win32API.WS_VISIBLE); //Set window style to "None". var moveResult = Win32API.MoveWindow(pluginWinHandle, 0, 0, width, height, true); //Move window to fixed position(up-left is (0,0), and low-right is (width, height)). //embed failed, and tries again if (!moveResult || embedResult == 0) { AppProcess.Kill(); if (MAXCOUNT-- > 0) { EmbedProcess(width, height); } } else { Win32API.ShowWindow(pluginWinHandle, (short)Win32API.SW_MAXIMIZE); } } catch (Exception ex) { var errorString = Win32API.GetLastError(); MessageBox.Show(errorString + ex.Message); } return(embedResult != 0); }
protected static void CleanupApp(AppProcess app) { if (app == null) { throw new ArgumentException("App cannot be null", nameof(app)); } int processId = app.ProcessId; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { ProcessUtility.KillProcessWindows(processId, _fileSystem, out string _, out string _); } else { var children = new HashSet <int>(); ProcessUtility.GetAllChildIdsUnix(processId, children, _fileSystem); foreach (var childId in children) { ProcessUtility.KillProcessUnix(childId, _fileSystem, out string _, out string _); } ProcessUtility.KillProcessUnix(processId, _fileSystem, out string _, out string _); } }
public void KillProcessTree(AppProcess process, CommandOptions options, TimeSpan timeout) { if (process == null) { throw new ArgumentNullException(nameof(process)); } string stdout; string stderr; if (_isWindows) { ProcessUtility.KillProcessWindows(process.ProcessId, _fileSystem, out stdout, out stderr); LogOutputs(stdout, stderr, options); } else { var children = new HashSet <int>(); ProcessUtility.GetAllChildIdsUnix(process.ProcessId, children, _fileSystem); foreach (var childId in children) { ProcessUtility.KillProcessUnix(childId, _fileSystem, out stdout, out stderr); LogOutputs(stdout, stderr, options); } ProcessUtility.KillProcessUnix(process.ProcessId, _fileSystem, out stdout, out stderr); LogOutputs(stdout, stderr, options); } process.Kill(timeout, _console); }
private void processThread(ref AppProcess process) { Console.WriteLine("startei process"); process.Process.Start(); process.Process.WaitForExit(); clearCurrentApp(); Console.WriteLine("Sai vazado"); }
public async Task TestProject_verbose_on_success_prints_all_output() { AppProcess unitTest = await _service.Test(_successfulTests, _successfulTests.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Assert.Equal(AppTask.Test, unitTest.Task); Assert.Equal(AppStatus.Success, unitTest.Status); Assert.NotEmpty(_console.LogOutput); }
public async Task TestProject_verbose_on_failure_prints_all_output() { AppProcess unitTest = await _service.Test(_failedTests, _failedTests.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Assert.Equal(AppTask.Test, unitTest.Task); Assert.Equal(AppStatus.Failure, unitTest.Status); Assert.Contains("Total tests:", _console.LogOutput, StringComparison.InvariantCulture); }
public async Task TestProject_will_return_test_for_path_pattern_and_expected_status(string pathPattern, AppStatus expectedStatus) { AppProcess test = await _service.Test(_application, _application.GetAppDirectoryPaths(_fileSystem) [0], TestOptions.Create(null, pathPattern), CancellationToken.None); Assert.Equal(AppTask.Test, test.Task); Assert.Equal(expectedStatus, test.Status); }
public async Task InstallProject_returns_process() { AppProcess process = await _service.Install(_application, _application.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Assert.Equal(AppTask.Install, process.Task); Assert.Equal(AppStatus.Success, process.Status); Assert.Equal(_application.Port, process.Port); }
public async Task <AppProcess> ShutdownBuildServer(CommandOptions options, CancellationToken cancellationToken) { AppProcess shutdownBuildServer = CreateProcess(FrameworkCommands.DotnetCore.ShutdownBuildServer, options, _fileSystem); shutdownBuildServer.Start(); await shutdownBuildServer.WaitForExitAsync(cancellationToken); return(shutdownBuildServer); }
public async Task InstallProject_sets_source_if_specified() { string source = "http://artifactory.org/nuget"; _application.Source = source; AppProcess process = await _service.Install(_application, _application.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Assert.Contains($"--source {source}", process.Process.StartInfo.Arguments, StringComparison.InvariantCulture); }
public virtual async Task <AppProcess> Install(Project project, string appDirectoryPath, CommandOptions options, CancellationToken cancellationToken) { AppProcess install = CreateProcess(InstallCommand, project, appDirectoryPath, options); install.Start(); await install.WaitForExitAsync(cancellationToken); return(install); }
public async Task WaitForExitAsync_returns_if_process_is_null() { AppProcess process = new AppProcess(null, AppTask.Test, AppStatus.Running); var task = process.WaitForExitAsync(CancellationToken.None); await task; Assert.True(task.IsCompleted); }
public virtual async Task <AppProcess> Test(Project project, string appDirectoryPath, CommandOptions options, CancellationToken cancellationToken) { AppProcess test = CreateProcess(TestCommand, project, appDirectoryPath, options); test.Start(); await test.WaitForExitAsync(cancellationToken); return(test); }
public async Task RunProject_returns_failure_status_on_thrown_exception() { AppProcess process = await _service.Start(_applicationError, _applicationError.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); await process.WaitForExitAsync(CancellationToken.None); Assert.Equal(AppStatus.Failure, process.Status); CleanupApp(process); }
public virtual async Task <AppProcess> Build(Project project, string appDirectoryPath, CommandOptions options, CancellationToken cancellationToken) { AppProcess build = CreateProcess(BuildCommand, project, appDirectoryPath, options); build.Start(); await build.WaitForExitAsync(cancellationToken); return(build); }
public virtual Task <AppProcess> Start(Project project, string appDirectoryPath, CommandOptions options, CancellationToken cancellationToken) { return(Task.Run(() => { AppProcess start = CreateProcess(StartCommand, project, appDirectoryPath, options); start.Start(); return start; }, cancellationToken)); }
public void OnKill_is_never_invoked_if_it_is_null() { int callCount = 0; AppProcess process = new AppProcess(new Process(), AppTask.Test, AppStatus.Running) { OnKill = null }; Assert.Equal(0, callCount); }
public async Task RunProject_starts_and_returns_process() { AppProcess app = await _service.Start(_application, _application.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Thread.Sleep(1000); Assert.Equal(AppTask.Start, app.Task); Assert.Equal(AppStatus.Running, app.Status); CleanupApp(app); }
public async Task RunProject_long_starts_and_prints_nothing() { AppProcess process = await _service.Start(_applicationLong, _applicationLong.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Thread.Sleep(1000); Assert.Equal(AppTask.Start, process.Task); Assert.Equal(AppStatus.Running, process.Status); Assert.Null(process.Port); CleanupApp(process); }
public async Task RunProject_verbose_starts_and_prints_all_output() { AppProcess process = await _service.Start(_application, _application.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); process.WaitForExit(); Assert.Equal(AppTask.Start, process.Task); Assert.Equal(AppStatus.Success, process.Status); Assert.Contains("Hello World!", _console.LogOutput, StringComparison.InvariantCulture); CleanupApp(process); }
public void OnKill_is_called_if_set_when_process_is_killed() { int callCount = 0; AppProcess process = new AppProcess(new Process(), AppTask.Test, AppStatus.Running) { OnKill = (processId) => callCount++ }; process.Kill(); Assert.Equal(1, callCount); }
public async Task RunProject_changes_status_from_running_to_success_on_exit() { var options = TestOptions.Create(); AppProcess process = await _service.Start(_application, _application.GetAppDirectoryPaths(_fileSystem)[0], options, CancellationToken.None); Assert.Equal(AppStatus.Running, process.Status); await process.WaitForExitAsync(CancellationToken.None); Assert.Equal(AppStatus.Success, process.Status); CleanupApp(process); }
public AppProcess FindOrCreateProcess(string processName) { AppProcess process = Processes.FirstOrDefault(p => p.Name == processName); if (process != null) return process; process = new AppProcess(); process.Name = processName; process.Type = "process"; Processes.Add(process); return process; }
/// <summary> /// Runs a process with Medium Privileges (using Windows Explorer as the base security model). /// </summary> /// <param name="appPath">Full path or relative to application</param> /// <param name="cmdParameters">Parameters to pass to application</param> /// <param name="waitForExit">TRUE is you want to wait until process completes</param> /// <returns></returns> private bool RunCustomAppWithMediumPrivilege(string appPath, string cmdParameters, bool waitForExit) { try { AppProcess.StartAppWithMediumPrivilegeFromUISession(appPath, cmdParameters, waitForExit); } catch (Exception exp) { Log.WriteSystemEventLog("Failed to run custom app with medium rights. Error:" + exp.ToString(), EventLogEntryType.Error); return(false); } return(true); }
public async Task RunProject_will_start_custom_port_if_specified() { _applicationLong.Port = 8080; AppProcess process = await _service.Start(_applicationLong, _applicationLong.GetAppDirectoryPaths(_fileSystem)[0], TestOptions.Create(), CancellationToken.None); Thread.Sleep(1000); Assert.Equal(AppTask.Start, process.Task); Assert.Equal(AppStatus.Running, process.Status); Assert.Equal(8080, process.Port); CleanupApp(process); }
public async Task KillProcesses_kills_all_dotnet_processes(bool isWindows, string expectedFileName, string expectedArguments) { _runtimeInfoMock.Setup(m => m.IsWindows).Returns(isWindows).Verifiable(); AppProcess process = await _service.Kill(TestOptions.Create(), CancellationToken.None); Assert.Equal(AppStatus.Success, process.Status); Assert.Equal(AppTask.Kill, process.Task); var startInfo = process.Process.StartInfo; Assert.Equal(expectedFileName, startInfo.FileName); Assert.Equal(expectedArguments, startInfo.Arguments); _runtimeInfoMock.Verify(); }
public static IUIItem GetControl(AppProcess process, MappedItem window, MappedItem control, AppManager appManager) { Process wProcess = Process.GetProcessesByName(process.Name).First(); Application application = Application.Attach(wProcess); Window appWindow = null; if (control.Type == "pane") { } /*IEnumerable<string> enumerable = application.GetWindows().Select(w => w.Title); IEnumerable<string> list2 = application.GetWindows().Select(w => w.AutomationElement.Current.Name); */ List<string> windowTitles2 = GetWindowsForProcess(process.Name); if (!window.Name.IsNullOrEmpty()) appWindow = application.GetWindow(SearchCriteria.ByAutomationId(window.Name), InitializeOption.NoCache); else { for (int i = 0; i < 5; i++) { List<string> windowTitles = GetWindowsForProcess(process.Name); string windowName = window.Text; string closestTitle = windowTitles[0]; decimal toleranceLevel = windowName.Length * 0.7m; foreach (string windowTitle in windowTitles) { int num1 = LevenshteinDistance.GetToleranceLevel(windowTitle, windowName); if (num1 < toleranceLevel) { toleranceLevel = num1; closestTitle = windowTitle; } } try { List<Window> windows = application.GetWindows(); appWindow = application.GetWindows().FirstOrDefault(w => w.AutomationElement.Current.Name.Equals(closestTitle)); if (appWindow == null) { List<IntPtr> handles = EnumerateProcessWindowHandles(wProcess.Id).ToList(); Dictionary<string, IntPtr> windowHandleDict = new Dictionary<string, IntPtr>(); StringBuilder builder = new StringBuilder(1024); foreach (IntPtr myIntPtr in handles) { GetWindowText(myIntPtr, builder, 1024); string windowTitle = builder.ToString(); windowHandleDict[windowTitle] = myIntPtr; } AutomationElement element = AutomationElement.FromHandle(windowHandleDict[closestTitle]); appWindow = new Win32Window(element, WindowFactory.Desktop, InitializeOption.NoCache, new NullWindowSession()); } break; } catch (Exception ex) { } } } BringWindowToFront(appWindow.AutomationElement.Current.NativeWindowHandle); if (control == null || control.Type == "window" || control.Equals(window)) return appWindow; Stack<MappedItem> mappedItemTree = new Stack<MappedItem>(); MappedItem currentMappedItem = control; if (window == null) { } while (currentMappedItem != window) { mappedItemTree.Push(currentMappedItem); currentMappedItem = appManager.GetMappedItem(currentMappedItem.ParentId); } IUIItem currentControl = appWindow; AutomationElement elemn; while (mappedItemTree.Count > 0) { MappedItem currentMappedItemControl = mappedItemTree.Pop(); if (!currentMappedItemControl.Name.IsNullOrEmpty()) { AutomationElement element = currentControl.AutomationElement.FindFirst(TreeScope.Descendants, new PropertyCondition(AutomationElement.AutomationIdProperty, currentMappedItemControl.Name)); //AutomationElement element = currentControl.GetElement(SearchCriteria.ByAutomationId(currentMappedItemControl.Name)); currentControl = new UIItem(element, new NullActionListener()); continue; } if (!string.IsNullOrEmpty(currentMappedItemControl.Text)) { currentControl = new UIItem(currentControl.GetElement(SearchCriteria.ByText(currentMappedItemControl.Text)), new NullActionListener()); continue; } } return currentControl; }
private void SetupScreenActions() { project = new Project(); project.Name = "TestProj"; project.ProjectFolder = @"C:\TestGhProj\" + project.Name; ProjectManager.CurrentProject = project; XmlFileWriter fileWriter = new XmlFileWriter(); fileWriter.SaveProject(); AppProcess process = new AppProcess{Name = "Process1"}; AppWindow window = new AppWindow{Name="Window1"}; AppWindow window2 = new AppWindow{Name="Window2"}; AppControl control = new AppControl(); AppControl control2 = new AppControl(); process.Children.Add(window); process.Children.Add(window2); window.Children.Add(control); window2.Children.Add(control2); control.WindowId = window.Id; control2.WindowId = window2.Id; window.ProcessId = process.Id; window2.ProcessId = process.Id; OnScreenAction action1 = new OnScreenAction(); action1.Operation = new ClickOperation(); action1.Operation.Parameters[0].Value.DisplayValue = "1"; action1.Operation.Parameters[1].Value.DisplayValue = "2"; action1.ControlId = control.Id; action1.WindowId = window.Id; Screenshot screenShot = new Screenshot(); screenShot.ImageFile = @"screenshot1.png"; screenShot.Adornments.Add(new ScreenshotClickAdornment { ClickX = 100, ClickY = 100 }); action1.Screenshot = screenShot; OnScreenAction action2 = new OnScreenAction(); action2.Operation = new ClickOperation(); action2.ControlId = control.Id; action2.WindowId = window.Id; OnScreenAction action3 = new OnScreenAction(); action3.Operation = new ClickOperation(); action3.ControlId = control.Id; action3.WindowId = window.Id; OnScreenAction action4 = new OnScreenAction(); action4.Operation = new ClickOperation(); action4.ControlId = control2.Id; action4.WindowId = window2.Id; OnScreenAction action5 = new OnScreenAction(); action5.Operation = new ClickOperation(); action5.ControlId = control2.Id; action5.WindowId = window2.Id; Screenshot screenShot2 = new Screenshot(); screenShot2.ImageFile = @"screenshot2.png"; screenShot2.Adornments.Add(new ScreenshotClickAdornment { ClickX = 300, ClickY = 250 }); action5.Screenshot = screenShot2; OnScreenAction action6 = new OnScreenAction(); action6.Operation = new ClickOperation(); action6.ControlId = control2.Id; action6.WindowId = window2.Id; Test test = new Test(); test.Name = "Test1"; for (int i = 0; i < 50; i++) { test.TestItems.Add(action1); test.TestItems.Add(action2); test.TestItems.Add(action3); test.TestItems.Add(action4); test.TestItems.Add(action5); test.TestItems.Add(action6); } Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); fileWriter.Write(test); stopWatch.Stop(); AppManager appManager = new AppManager(); appManager.Processes.Add(process); fileWriter.Write(appManager); }