public void executePattern(AutomationElement subject, AutomationPattern inPattern) { switch (inPattern.ProgrammaticName) { case "InvokePatternIdentifiers.Pattern": { InvokePattern invoke = (InvokePattern)subject.GetCurrentPattern(InvokePattern.Pattern); invoke.Invoke(); break; } case "SelectionItemPatternIdentifiers.Pattern": { SelectionItemPattern select = (SelectionItemPattern)subject.GetCurrentPattern(SelectionItemPattern.Pattern); select.Select(); break; } case "TogglePatternIdentifiers.Pattern": { TogglePattern toggle = (TogglePattern)subject.GetCurrentPattern(TogglePattern.Pattern); toggle.Toggle(); break; } case "ExpandCollapsePatternIdentifiers.Pattern": { ExpandCollapsePattern exColPat = (ExpandCollapsePattern)subject.GetCurrentPattern(ExpandCollapsePattern.Pattern); // exColPat.Expand(); break; } } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal ScrollItemPatternWrapper(AutomationElement element, string testSuite, TestPriorities priority, TypeOfControl typeOfControl, TypeOfPattern typeOfPattern, string dirResults, bool testEvents, IApplicationCommands commands) : base(element, testSuite, priority, typeOfControl, typeOfPattern, dirResults, testEvents, commands) { Comment("Creating ScrollItemTests"); _pattern = (ScrollItemPattern)GetPattern(m_le, m_useCurrent, ScrollItemPattern.Pattern); if (_pattern == null) ThrowMe(CheckType.IncorrectElementConfiguration, Helpers.PatternNotSupported + ": ScrollItemPattern"); // Find the ScrollPattern _container = m_le; while (_container != null && !(bool)_container.GetCurrentPropertyValue(AutomationElement.IsScrollPatternAvailableProperty)) _container = TreeWalker.ControlViewWalker.GetParent(_container); // Check to see if we actual found the container of the scrollitem if (_container == null) ThrowMe(CheckType.IncorrectElementConfiguration, "Element does not have a container with ScrollPattern"); Comment("Found scroll container: " + Library.GetUISpyLook(_container)); _scrollPattern = (ScrollPattern)_container.GetCurrentPattern(ScrollPattern.Pattern) as ScrollPattern; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- public MultipleViewTests(AutomationElement element, TestPriorities priority, string dirResults, bool testEvents, TypeOfControl typeOfControl, IApplicationCommands commands) : base(element, TestSuite, priority, typeOfControl, TypeOfPattern.MultipleView, dirResults, testEvents, commands) { m_pattern = (MultipleViewPattern)element.GetCurrentPattern(MultipleViewPattern.Pattern); if (m_pattern == null) throw new Exception(Helpers.PatternNotSupported); }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- protected TogglePatternWrapper(AutomationElement element, string testSuite, TestPriorities priority, TypeOfControl typeOfControl, TypeOfPattern typeOfPattern, string dirResults, bool testEvents, IApplicationCommands commands) : base(element, testSuite, priority, typeOfControl, typeOfPattern, dirResults, testEvents, commands) { _pattern = (TogglePattern)element.GetCurrentPattern(TogglePattern.Pattern); if (_pattern == null) throw new Exception("TogglePattern: " + Helpers.PatternNotSupported); }
public static void Check(AutomationElement element) { // element.SetFocus(); //SendKeys.SendWait(" "); TogglePattern togglePattern = element.GetCurrentPattern(TogglePattern.Pattern) as TogglePattern; togglePattern.Toggle(); }
/// <summary> /// Gets the content of the AutomationElement of control type DataGrid. /// </summary> /// <param name="dataGrid">A data grid control.</param> /// <returns>A data table containing the contents of the passed data grid.</returns> public static DataTable GetDataGridContent(AutomationElement dataGrid, string tableName = "DataGrid") { if (dataGrid.Current.ControlType != ControlType.DataGrid) { throw new Exception("Invalid control type passed to GetDataGridContent."); } try { GridPattern gp = (GridPattern)dataGrid.GetCurrentPattern(GridPattern.Pattern); TablePattern tp = (TablePattern)dataGrid.GetCurrentPattern(TablePattern.Pattern); AutomationElement[] headers = tp.Current.GetColumnHeaders(); DataTable dt = new DataTable(tableName); foreach (AutomationElement columnHeader in headers) { dt.Columns.Add(columnHeader.Current.Name, typeof(String)); } int colCount = gp.Current.ColumnCount; int rowCount = gp.Current.RowCount; for (int r = 0; r < rowCount; r++) { DataRow dr = dt.NewRow(); for (int c = 0; c < colCount; c++) { dr[c] = gp.GetItem(r, c).Current.Name; } dt.Rows.Add(dr); } return dt; } catch (Exception ex) { Log.Write(ex); return new DataTable(); } }
public static string GetText(AutomationElement element) { string content = string.Empty; TextPattern txtPattern = element.GetCurrentPattern(TextPattern.Pattern) as TextPattern; if (txtPattern != null) { content = txtPattern.DocumentRange.GetText(-1); } return content; }
private void EmptyTextFromChild(AutomationElement element) { if (element.GetSupportedPatterns().Contains(ValuePattern.Pattern)) { ((ValuePattern)element.GetCurrentPattern(ValuePattern.Pattern)).SetValue(string.Empty); } else if (element.GetSupportedPatterns().Contains(TextPattern.Pattern)) { TextPatternRange document = ((TextPattern)Element.GetCurrentPattern(TextPattern.Pattern)).DocumentRange; AutomationElement[] children = document.GetChildren(); foreach (var child in children) { EmptyTextFromChild(child); } } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal SelectionItemPatternWrapper(AutomationElement element, string testSuite, TestPriorities priority, TypeOfControl typeOfControl, TypeOfPattern typeOfPattern, string dirResults, bool testEvents, IApplicationCommands commands) : base(element, testSuite, priority, typeOfControl, typeOfPattern, dirResults, testEvents, commands) { _pattern = (SelectionItemPattern)GetPattern(m_le, m_useCurrent, SelectionItemPattern.Pattern); if (_pattern == null) throw new Exception(Helpers.PatternNotSupported + ": SelectionItemPattern"); _selectionContainer = _pattern.Current.SelectionContainer; if (_selectionContainer != null) { _selectionPattern = _selectionContainer.GetCurrentPattern(SelectionPattern.Pattern) as SelectionPattern; if (_selectionPattern == null) throw new ArgumentException("Could not find the SelectionContainer's SelectionPattern"); } }
public AppHost(string program, string args) { // Start up the program and find it _process = Process.Start(program, args); _hwnd = ActiveWaitForHwnd(_process.Id); if (_hwnd == IntPtr.Zero) { throw new InvalidOperationException("app never stabilized"); } // Find it _element = AutomationElement.FromHandle(_hwnd); if (_element == null) { throw new InvalidOperationException(); } _windowPattern = (WindowPattern)_element.GetCurrentPattern(WindowPattern.Pattern); }
public ExplorerHost() { // Start up Explorer and find it System.Diagnostics.Process.Start("cmd.exe", "/c start %SystemDrive%\\windows\\system32"); // Wait briefly System.Threading.Thread.Sleep(2000 /* ms */); // Find it _element = AutomationElement.RootElement.FindFirst(TreeScope.Children, new PropertyCondition(AutomationElement.NameProperty, "system32")); if (_element == null) { throw new InvalidOperationException(); } _hwnd = _element.Current.NativeWindowHandle; _windowPattern = (WindowPattern)_element.GetCurrentPattern(WindowPattern.Pattern); }
private static WindowPattern GetWindowPattern(AutomationElement targetControl) { WindowPattern windowPattern = null; try { windowPattern = targetControl.GetCurrentPattern(WindowPattern.Pattern) as WindowPattern; } catch (InvalidOperationException) { // object doesn't support the WindowPattern control pattern return null; } // Make sure the element is usable. if (false == windowPattern.WaitForInputIdle(10000)) { // Object not responding in a timely manner return null; } return windowPattern; }
/// <summary> /// Gets the first selected content of the AutomationElement of control type ComboBox. /// </summary> /// <param name="comboBoxControl">A combobox control.</param> /// <returns>Only the first selected item in text format.</returns> public static string GetComboBoxContent(AutomationElement comboBoxControl) { if (comboBoxControl.Current.ControlType != ControlType.ComboBox) { throw new Exception("Invalid control type passed to GetRadioButtonCheckState."); } try { SelectionPattern sp = (SelectionPattern)comboBoxControl.GetCurrentPattern(SelectionPattern.Pattern); AutomationElement[] selected = sp.Current.GetSelection(); if (selected.Length > 0) { return selected[0].Current.Name; } return String.Empty; } catch (Exception ex) { Log.Write(ex); return String.Empty; } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal void TS_CurrentEqualsSelection(AutomationElement container, ArrayList array, CheckType checkType) { int count = 0; SelectionPattern sp = container.GetCurrentPattern(SelectionPattern.Pattern) as SelectionPattern; if (sp == null) ThrowMe(checkType, "Element does not support SelectionPattern"); AutomationElement[] les = sp.Current.GetSelection(); Comment("There are " + les.Length + " selected items according to element.Current.GetSelection()"); Comment("There should be " + array.Count + " items selected"); if (!les.Length.Equals(array.Count)) ThrowMe(checkType, "m_pattern.Selection == " + count + ", but there should be " + array.Count + " items selected"); Comment("Now compare that Current.GetSelection() is what should be selected"); foreach (AutomationElement le in les) { Comment(" - Verify: (" + Library.GetUISpyLook(le) + ").IsSelected = true"); if (array.IndexOf(le).Equals(false)) ThrowMe(checkType, "The selected elements does not equal to what it should be"); } // Now compare what array says SelectionItemPattern sip; Comment("Now compare what we expected to be selected (items we called Select() on"); foreach (AutomationElement le in array) { Comment(" - Verify: (SelectionItemPattern)" + Library.GetUISpyLook(le) + ".GetCurrentPattern(SelectionItemPattern.Pattern).IsSelected should be true"); sip = (SelectionItemPattern)le.GetCurrentPattern(SelectionItemPattern.Pattern); if (sip.Current.IsSelected.Equals(false)) ThrowMe(CheckType.Verification, "Element is not selected when it should be"); } m_TestStep++; }
public Table(AutomationElement element) : base(element) { _pattern = (GridPattern)element.GetCurrentPattern(GridPattern.Pattern); }
protected void Select(AutomationElement element) { SelectionItemPattern select = (SelectionItemPattern)element.GetCurrentPattern(SelectionItemPattern.Pattern); select.Select(); }
protected void Click(AutomationElement element) { var click = element.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern; click.Invoke(); }
/// ------------------------------------------------------------------- /// <summary>HELPER: Obtains the pattern object and returns true or false depending on success</summary> /// ------------------------------------------------------------------- private static bool GetPatternObject(AutomationElement element, AutomationPattern automationPattern, ref object patternObj) { bool succeeded = true; try { patternObj = element.GetCurrentPattern(automationPattern); } catch (InvalidOperationException exception) { Dump(exception.ToString(), true, element); succeeded = false; } return succeeded; }
public static void AutomationElementGetCurrentPattern(AutomationElement element) { Dump("GetCurrentPattern(InvokePattern.Pattern)", true, element); try { object obj = element.GetCurrentPattern(InvokePattern.Pattern); } catch (Exception exception) { VerifyException(element, exception, typeof(ElementNotAvailableException), typeof(InvalidOperationException) /*{"Unsupported Pattern"} */ ); } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- private void TS_CollapseMenu(AutomationElement menu, CheckType checkType) { if (false == (bool)menu.GetCurrentPropertyValue(AutomationElement.IsExpandCollapsePatternAvailableProperty)) { ThrowMe(checkType, "Menu does not support ExpandCollapsePattern"); } int timeout = 0; ExpandCollapsePattern ecp = menu.GetCurrentPattern(ExpandCollapsePattern.Pattern) as ExpandCollapsePattern; ecp.Collapse(); // Yikes sleep! But we are testing events, so cannot rely on eventing to determine when we are done. while (ecp.Current.ExpandCollapseState != ExpandCollapseState.Collapsed && timeout < MAX_TIME) { Thread.Sleep(INCREMENT); timeout += INCREMENT; } m_TestStep++; }
private void DoOperations() { InternetExplorerOptions ieOptions = new InternetExplorerOptions(); ieOptions.IntroduceInstabilityByIgnoringProtectedModeSettings = true; //IWebDriver driverIE = new InternetExplorerDriver(@"D:\COMPARTIDO_PUBLICO\RPA\TCS RPA V1.2 - Training\Sample\Automation - Proceso Cese - JJRDC\Mainframe Automation\Mainframe Automation Solution\packages\Selenium.WebDriver.IEDriver.3.5.1\driver", ieOptions); IWebDriver driverIE = new InternetExplorerDriver(System.Configuration.ConfigurationManager.AppSettings["IEDriverPath"], ieOptions); //driverIE.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(60); driverIE.Navigate().GoToUrl("http://*****:*****@id,'btnAlertaDismiss')]")).Click(); driverIE.FindElement(By.XPath("//*[contains(@id,'btnAlertaDismiss')]")).Click(); //acts.SendKeys(Keys.Enter); //acts.SendKeys(Keys.Enter); }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal void TS_IsSelected(AutomationElement element, bool ShouldElementBeSelected, CheckType checkType) { SelectionItemPattern sip = (SelectionItemPattern)element.GetCurrentPattern(SelectionItemPattern.Pattern); // Check to make sure all elements in if (!sip.Current.IsSelected.Equals(ShouldElementBeSelected)) ThrowMe(checkType, "IsSelected returned " + !ShouldElementBeSelected + " but expected " + ShouldElementBeSelected); Comment("IsSelected(" + Library.GetUISpyLook(element) + ") = " + sip.Current.IsSelected.Equals(ShouldElementBeSelected)); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal void SetPatterns(AutomationElement element) { if (element == null) return; foreach (AutomationPattern ap in element.GetSupportedPatterns()) { Comment("Element supports pattern: " + Automation.PatternName(ap).ToString()); m_cachedPatternList.Add(element.GetCurrentPattern(ap)); } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal void TS_AddElementToSelection(AutomationElement element, Type expectedException, CheckType checkType) { string call = "SelectionItemPattern.AddToSelection()"; try { SelectionItemPattern sip = element.GetCurrentPattern(SelectionItemPattern.Pattern) as SelectionItemPattern; if (sip == null) ThrowMe(CheckType.Verification, "Could not get SelectionItemPattern for " + Library.GetUISpyLook(element)); Comment("Before calling " + call + " on LE(" + Library.GetUISpyLook(element) + ").IsSelected = " + sip.Current.IsSelected); sip.AddToSelection(); Thread.Sleep(1); Comment("After calling " + call + " on LE(" + Library.GetUISpyLook(element) + ").IsSelected = " + sip.Current.IsSelected); } catch (Exception actualException) { if (Library.IsCriticalException(actualException)) throw; Comment("Exception occured : " + actualException.GetType().ToString()); TestException(expectedException, actualException, call, checkType); m_TestStep++; return; } TestNoException(expectedException, call, checkType); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary>Helper: Press button</summary> /// ------------------------------------------------------------------- void HelperPressButton(AutomationElement element, ActionMethod actionBY, CheckType checkType) { Library.ValidateArgumentNonNull(element, "Button AutomationElement"); string name = element.Current.Name; switch (actionBY) { case ActionMethod.KeyPadOnly: { string buffer = element.Current.AccessKey; if (!string.IsNullOrEmpty(buffer)) { // There is an access key so use it Comment("Pressing keyboard access key \"" + element.Current.AccessKey + "\""); Input.SendKeyboardInput(element.Current.AccessKey); } else { // No access key so set focus and press enter Comment("Setting focus to \"{0}\" and pressing ENTER", element.Current.Name); element.SetFocus(); Input.SendKeyboardInput(System.Windows.Input.Key.Enter); } } break; case ActionMethod.MouseClick: { Comment("Moving mouse to \"" + element.Current.Name + "\" and left clicking"); Input.MoveToAndClick(element); } break; default: { if (!(bool)element.GetCurrentPropertyValue(AutomationElement.IsInvokePatternAvailableProperty)) ThrowMe(checkType, "Button \"" + name + "\" does not support Invoke pattern"); Comment("Calling InvokePattern.Invoke() on \"" + name + "\""); ((InvokePattern)element.GetCurrentPattern(InvokePattern.Pattern)).Invoke(); } break; } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal void TS_RemoveElementFromSelection(AutomationElement element, Type expectedException, CheckType checkType) { string call = "SelectionItemPattern.RemoveFromSelection()"; try { Comment("Trying to RemoveElementFromSelection(" + Library.GetUISpyLook(element) + ")"); SelectionItemPattern sip = (SelectionItemPattern)element.GetCurrentPattern(SelectionItemPattern.Pattern); sip.RemoveFromSelection(); Thread.Sleep(1); Comment("After calling RemoveElementFromSelection on LE(" + Library.GetUISpyLook(element) + ").IsSelected = " + sip.Current.IsSelected); } catch (Exception actualException) { if (Library.IsCriticalException(actualException)) throw; Comment("Exception occured : " + actualException.GetType().ToString()); TestException(expectedException, actualException, call, checkType); return; } TestNoException(expectedException, call, checkType); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal SelectionItemPattern getSelectionItemPattern(AutomationElement element, CheckType checkType) { SelectionItemPattern sip = (SelectionItemPattern)element.GetCurrentPattern(SelectionItemPattern.Pattern); if (sip == null) ThrowMe(checkType, "\"" + Library.GetUISpyLook(element) + " does not support SelectionItemPattern"); return sip; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal void TSC_SelectElement(AutomationElement le, string name, Type expectedException, CheckType checkType) { SelectionItemPattern sip = le.GetCurrentPattern(SelectionItemPattern.Pattern) as SelectionItemPattern; if (sip == null) ThrowMe(checkType, "Could not get the selection item pattern for " + Library.GetUISpyLook(le)); else Comment("Call Select() on : " + Library.GetUISpyLook(le)); sip.Select(); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- private void TS_InvokePatternInvoke(AutomationElement element, CheckType checkType) { InvokePattern ip = element.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern; if (ip == null) ThrowMe(checkType, "Element[" + element.Current.Name + "] does not support InvokePattern"); ip.Invoke(); Comment("InvokePattern.Invoke(element[" + element.Current.Name + "])"); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal void TS_IsSelectable(AutomationElement element, bool Selectable, CheckType checkType) { SelectionItemPattern sip = (SelectionItemPattern)element.GetCurrentPattern(SelectionItemPattern.Pattern); if (!((sip != null) == Selectable)) ThrowMe(checkType, "Element(" + Library.GetUISpyLook(element) + ") does not support the SelectionItemPattern so cannot be selected"); string does = "does " + (Selectable.Equals(true) ? "" : "not "); Comment("Element(" + Library.GetUISpyLook(element) + ") " + does + "supports the SelectionItemPattern"); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- private void TS_ExpandCollapsePatternExpand(AutomationElement element, CheckType checkType) { ExpandCollapsePattern ecp = element.GetCurrentPattern(ExpandCollapsePattern.Pattern) as ExpandCollapsePattern; if (ecp == null) ThrowMe(checkType, "Element[" + element.Current.Name + "] does not support ExpandCollapsePattern"); ecp.Expand(); Comment("Expanded element[" + element.Current.Name); m_TestStep++; }