/// <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);
}
