public void Value() { CheckDisposed(); AccessibilityHelper child = m_ah.FindChild("informationBar", AccessibleRole.None); Assert.AreEqual("Information Bar Text", child.Value); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Verifies that each menu item has an accessible name. /// </summary> /// <param name="menu">Menu to test</param> /// <param name="parent">The parent menu item</param> /// <param name="prevMenu">The menu item before this</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int VerifyMenuItemNames(AccessibilityHelper menu, AccessibilityHelper parent, AccessibilityHelper prevMenu) { int nErrors = 0; if (menu.Role != AccessibleRole.Separator && (menu.Name == null || menu.Name.Length <= 0)) { Console.WriteLine( "Can't get menu name. Parent is '{0}', previous menu item is '{1}'. {2}", parent != null ? parent.Name : "<null>", prevMenu != null ? prevMenu.Name : "<null>", menu.IsRealAccessibleObject && menu.ChildCount > 0 ? "Not testing subitems." : ""); nErrors++; } else if (menu.IsRealAccessibleObject) { AccessibilityHelper prevChild = null; foreach (AccessibilityHelper child in menu) { nErrors += VerifyMenuItemNames(child, menu, prevChild); prevChild = child; } } return(nErrors); }
public void FindChild() { CheckDisposed(); AccessibilityHelper child = m_ah.FindChild("informationBar", AccessibleRole.None); Assert.IsNotNull(child); Assert.AreEqual("informationBar", child.Name); Assert.AreEqual(AccessibleRole.Window, child.Role); child = m_ah.FindChild(null, AccessibleRole.Client); Assert.IsNotNull(child); Assert.AreEqual("dummyTestForm", child.Name); Assert.AreEqual(AccessibleRole.Client, child.Role); child = m_ah.FindChild("informationBar", AccessibleRole.Window); Assert.IsNotNull(child); Assert.AreEqual("informationBar", child.Name); Assert.AreEqual(AccessibleRole.Window, child.Role); child = m_ah.FindChild("draftView", AccessibleRole.Client); Assert.IsNotNull(child); Assert.AreEqual("draftView", child.Name); Assert.AreEqual(AccessibleRole.Client, child.Role); child = m_ah.FindChild("NotExistantChild", AccessibleRole.None); Assert.IsNull(child); child = m_ah.FindChild(null, AccessibleRole.None); Assert.IsNull(child); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Loop through all menu items to make sure that they are loaded (some are created /// only when they show, but afterwards they still exist). /// </summary> /// <param name="parent"><see cref="AccessibilityHelper"/> of the main window</param> /// ------------------------------------------------------------------------------------ public void ActivateAllMenuItems(AccessibilityHelper parent) { CheckDisposed(); foreach (AccessibilityHelper child in parent) { if (child.Role == AccessibleRole.MenuBar && child.Name != "System") { m_app.SendKeys("%"); foreach (AccessibilityHelper menu in child) { Debug.WriteLine("----------------------------------------"); Debug.WriteLine(string.Format("Activating main frame menu {0} (Role: {1})", menu.Name, menu.Role)); if (menu.IsRealAccessibleObject) { m_app.SendKeys("{DOWN}"); Debug.WriteLine("{DOWN}"); ActivateThisMenu(menu); } Debug.WriteLine("{RIGHT}"); m_app.SendKeys("{RIGHT}"); } Debug.WriteLine("{ESC}"); m_app.SendKeys("{ESC}"); } } }
public void AccessibleObjectFromPoint() { AccessibilityHelper child = m_ah.FindChild("informationBar", AccessibleRole.None); Rect rect; Win32.GetWindowRect((IntPtr)child.HWnd, out rect); Point pt = new Point(rect.left, rect.top); AccessibilityHelper test = new AccessibilityHelper(pt); Assert.AreEqual(child.HWnd, test.HWnd); }
public void Init() { CheckDisposed(); m_proc = Process.Start(@"DummyTestExe.exe"); m_proc.WaitForInputIdle(); while (Process.GetProcessById(m_proc.Id).MainWindowHandle == IntPtr.Zero) Thread.Sleep(100); m_proc.WaitForInputIdle(); Win32.SetForegroundWindow(m_proc.MainWindowHandle); m_ah = new AccessibilityHelper(m_proc.MainWindowHandle); }
public void Init() { m_proc = Process.Start(@"DummyTestExe.exe"); m_proc.WaitForInputIdle(); while (Process.GetProcessById(m_proc.Id).MainWindowHandle == IntPtr.Zero) { Thread.Sleep(100); } m_proc.WaitForInputIdle(); Win32.SetForegroundWindow(m_proc.MainWindowHandle); m_ah = new AccessibilityHelper(m_proc.MainWindowHandle); }
public void VerifyMenuItemNames() { int nErrors = 0; AccessibilityHelper prevChild = null; foreach (AccessibilityHelper child in m_app.MainAccessibilityHelper) { if (child.Role == AccessibleRole.MenuBar) { nErrors += VerifyMenuItemNames(child, m_app.MainAccessibilityHelper, prevChild); prevChild = child; } } Assert.AreEqual(0, nErrors, string.Format("{0} menu names couldn't be read. " + "The other tests will fail. See 'Standard Out' for details.", nErrors)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Loop through all menu items (and sub-menus) of one menu and check help text in the /// status bar. /// </summary> /// <param name="menuParent">The main frame menu <see cref="AccessibilityHelper"/>, e.g. /// for File.</param> /// ------------------------------------------------------------------------------------ protected int CheckStatusbarMenuTexts(AccessibilityHelper menuParent) { int nErrors = 0; // Because we're really opening the menu, we have one additional layer, that is // usually not visible (if you inspect it with AccExplorer, e.g): the window. // This consists also only of 1 child foreach (AccessibilityHelper menuWindow in menuParent) { // There should be only 1 popup menu for the menuParent... foreach (AccessibilityHelper menuPopup in menuWindow) { Debug.WriteLine(string.Format("Menu popup {0} (#children: {1}, role: {2})", menuPopup.Name, menuPopup.ChildCount, menuPopup.Role)); foreach (AccessibilityHelper menuItem in menuPopup) { if (menuItem.Role == AccessibleRole.Separator) { Debug.WriteLine("Separator -------"); } else { nErrors += CheckMenuHelp(menuItem.Name); if (menuItem.IsRealAccessibleObject) { Debug.WriteLine(string.Format("Sub Menu {0} (role: {1})", menuItem.Name, menuItem.Role)); Debug.WriteLine("{RIGHT}"); m_app.SendKeys("{RIGHT}"); nErrors += CheckStatusbarMenuTexts(menuItem); } else { Debug.WriteLine(string.Format("Menu item {0}", menuItem.Name)); } Debug.WriteLine("{DOWN}"); m_app.SendKeys("{DOWN}"); } } } } Debug.WriteLine("{ESC}"); m_app.SendKeys("{ESC}"); return(nErrors); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Checks the menu shortcuts for a particular menu /// </summary> /// <param name="menu">The menu to test</param> /// <param name="shortCuts">All short cuts found so far</param> /// <param name="menuNames">All menu names found so far</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ private int CheckMenuNameShortCutUniqueness(AccessibilityHelper menu, Hashtable shortCuts, Hashtable menuNames) { int nErrors = 0; if (menu.Role == AccessibleRole.MenuItem) { string[] menuNameParts = menu.Name.Split(new char[] { '\t' }); if (menuNameParts.Length > 1) { string shortCut = menuNameParts[menuNameParts.Length - 1]; if (!shortCuts.Contains(shortCut)) { shortCuts.Add(shortCut, menu.Name); } else { Console.WriteLine("\tThe shortcut '{0}' is used by '{1}' and by '{2}'", shortCut, shortCuts[shortCut], menu.Name); nErrors++; } } string name = menuNameParts[0].TrimEnd(new char[] { '.', ' ' }); if (!menuNames.Contains(name)) { menuNames.Add(name, menu.Parent.Name); } else { Console.WriteLine("\tThe menu name '{0}' is used by '{1}' and by '{2}'", name, menu.Parent.Name, menuNames[name]); nErrors++; } } if (menu.IsRealAccessibleObject) { foreach (AccessibilityHelper child in menu) { nErrors += CheckMenuNameShortCutUniqueness(child, shortCuts, menuNames); } } return(nErrors); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Test the menu capitalization and "Book Title" convention /// </summary> /// <param name="menu">Menu to test</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int CheckMenuCapitalization(AccessibilityHelper menu) { int nErrors = 0; if (menu.Role != AccessibleRole.Separator && menu.Role != AccessibleRole.MenuPopup && menu.Name != null && menu.Name.Length > 0) { if (!Char.IsUpper(menu.Name[0]) && !Char.IsDigit(menu.Name[0])) { Console.WriteLine("\t'{0}' is not capitalized nor digit", menu.Name); nErrors++; } String[] menuNameParts = menu.Name.Split(new char[] { ' ' }); for (int i = 1; i < menuNameParts.Length; i++) { if (Char.IsLower(menuNameParts[i][0])) { switch (menuNameParts[i]) { case "the": //these are okay case "or": case "and": case "a": case "of": case "in": break; default: // any other lower case is not Console.WriteLine( "\t'{0}' does not follow 'Book Title' convention", menu.Name); nErrors++; break; } } } } if (menu.IsRealAccessibleObject) { foreach (AccessibilityHelper child in menu) { nErrors += CheckMenuCapitalization(child); } } return(nErrors); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Find the nth child window with the specified name and/or role. /// </summary> /// <param name="name">Accessibility name of the matching window, or <c>null</c></param> /// <param name="role">Accessibility role of the matching window, or /// <see cref="AccessibleRole.None"/>.</param> /// <param name="nWhich">Number of specified child to find</param> /// <param name="nLevelsToRecurse">How much levels to go down. <c>0</c> if you want /// to search only in the immediate children.</param> /// <returns>A new <see cref="AccessibilityHelper"/> object that wraps the matched /// window.</returns> /// <remarks>If you provide only one parameter, it matches only that parameter. /// If you specify both parameters it tries to match both. </remarks> /// ------------------------------------------------------------------------------------ public AccessibilityHelper FindNthChild(string name, AccessibleRole role, ref int nWhich, int nLevelsToRecurse) { if (name == null && role == AccessibleRole.None) { return(null); } AccessibilityHelper ah = null; foreach (AccessibilityHelper child in this) { if (child == null) { continue; } // does this object match? if ((name == null || name == child.Name) && (role == AccessibleRole.None || role == child.Role)) { nWhich--; if (nWhich <= 0) { return(child); } } if (child.m_fRealAccessibleObject) { if (nLevelsToRecurse > 0) { // look through the child objects ah = child.FindNthChild(name, role, ref nWhich, nLevelsToRecurse - 1); if (ah != null) { return(ah); } } } } return(null); }
public void FindNthChild() { CheckDisposed(); Process proc = m_proc; AccessibilityHelper ah = m_ah; // start second instance Init(); // now look for the second instance int nWhich = 1; AccessibilityHelper first = m_ah.Parent.FindNthChild("dummyTestForm", AccessibleRole.None, ref nWhich, 0); nWhich = 2; AccessibilityHelper second = m_ah.Parent.FindNthChild("dummyTestForm", AccessibleRole.None, ref nWhich, 0); nWhich = 3; AccessibilityHelper none = m_ah.Parent.FindNthChild("dummyTestForm", AccessibleRole.None, ref nWhich, 0); int hwnd1 = m_proc.MainWindowHandle.ToInt32(); int hwnd2 = proc.MainWindowHandle.ToInt32(); int foundHwnd1 = first.HWnd; int foundHwnd2 = second.HWnd; // Close the second instance EndTest(); m_proc = proc; m_ah = ah; // now test that we got the right window. Do this after closing the second // instance, because if it fails the rest of this method isn't executed Assert.AreEqual(hwnd1, foundHwnd1); Assert.AreEqual(hwnd2, foundHwnd2); Assert.IsTrue(hwnd1 != foundHwnd2); Assert.IsNull(none); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Recurse the menus to make sure no menus with sub menus contain trailing ellipses /// in the menu text. /// </summary> /// <param name="menu">Menu to test</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int CheckMenuEllipses(AccessibilityHelper menu) { int nErrors = 0; if (menu.Role == AccessibleRole.MenuPopup) { if (menu.Name.Trim().EndsWith("...")) { Console.WriteLine("\tSub menu '{0}' has ellipses in name", menu.Name); nErrors++; } } if (menu.IsRealAccessibleObject) { foreach (AccessibilityHelper child in menu) { nErrors += CheckMenuEllipses(child); } } return(nErrors); }
public void Parent_Navigate() { AccessibilityHelper child = m_ah.FindChild("informationBar", AccessibleRole.None); AccessibilityHelper parent = child.Parent; Assert.AreEqual("dummyTestForm", parent.Name); AccessibilityHelper draftView = child.Navigate(AccessibleNavigation.Down); Assert.IsNotNull(draftView); Assert.AreEqual("draftView", draftView.Name); AccessibilityHelper navChild = m_ah.Navigate(AccessibleNavigation.FirstChild); Assert.AreEqual("System", navChild.Name); navChild = navChild.Navigate(AccessibleNavigation.Next); Assert.IsNull(navChild.Name); navChild = navChild.Navigate(AccessibleNavigation.Next); Assert.AreEqual("Application", navChild.Name); navChild = navChild.Navigate(AccessibleNavigation.Next); Assert.AreEqual("dummyTestForm", navChild.Name); navChild = navChild.Navigate(AccessibleNavigation.Next); Assert.IsNull(navChild); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Recurse the menus to make sure no menus have duplicate hotkeys in the menu items /// </summary> /// <param name="menu">Menu to test</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int CheckMenuHotkeys(AccessibilityHelper menu) { int nErrors = 0; ArrayList rgMenuItems = new ArrayList(20); foreach (AccessibilityHelper child in menu) { rgMenuItems.Add(child); if (child.IsRealAccessibleObject) { nErrors += CheckMenuHotkeys(child); } } for (int id1 = 0; id1 < rgMenuItems.Count; id1++) { AccessibilityHelper child1 = (AccessibilityHelper)rgMenuItems[id1]; if (child1.Role != AccessibleRole.Separator) { for (int id2 = id1 + 1; id2 < rgMenuItems.Count; id2++) { AccessibilityHelper child2 = (AccessibilityHelper)rgMenuItems[id2]; if (child2.Role != AccessibleRole.Separator && child1.Shortcut == child2.Shortcut && child1.Shortcut != null && child1.Shortcut.Length != 0) { Console.WriteLine("\tThe hotkey '{0}' is used by '{1}' and by '{2}'", child1.Shortcut, child1.Name, child2.Name); nErrors++; } } } } return(nErrors); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Verifies that each menu item has an accessible name. /// </summary> /// <param name="menu">Menu to test</param> /// <param name="parent">The parent menu item</param> /// <param name="prevMenu">The menu item before this</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int VerifyMenuItemNames(AccessibilityHelper menu, AccessibilityHelper parent, AccessibilityHelper prevMenu) { int nErrors = 0; if (menu.Role != AccessibleRole.Separator && (menu.Name == null || menu.Name.Length <= 0)) { Console.WriteLine( "Can't get menu name. Parent is '{0}', previous menu item is '{1}'. {2}", parent != null ? parent.Name : "<null>", prevMenu != null ? prevMenu.Name : "<null>", menu.IsRealAccessibleObject && menu.ChildCount > 0 ? "Not testing subitems." : ""); nErrors++; } else if (menu.IsRealAccessibleObject) { AccessibilityHelper prevChild = null; foreach(AccessibilityHelper child in menu) { nErrors += VerifyMenuItemNames(child, menu, prevChild); prevChild = child; } } return nErrors; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Checks the menu shortcuts for a particular menu /// </summary> /// <param name="menu">The menu to test</param> /// <param name="shortCuts">All short cuts found so far</param> /// <param name="menuNames">All menu names found so far</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ private int CheckMenuNameShortCutUniqueness(AccessibilityHelper menu, Hashtable shortCuts, Hashtable menuNames) { int nErrors = 0; if (menu.Role == AccessibleRole.MenuItem) { string[] menuNameParts = menu.Name.Split(new char[] { '\t' }); if (menuNameParts.Length > 1) { string shortCut = menuNameParts[menuNameParts.Length - 1]; if (!shortCuts.Contains(shortCut)) { shortCuts.Add(shortCut, menu.Name); } else { Console.WriteLine("\tThe shortcut '{0}' is used by '{1}' and by '{2}'", shortCut, shortCuts[shortCut], menu.Name); nErrors++; } } string name = menuNameParts[0].TrimEnd(new char[] { '.', ' ' }); if (!menuNames.Contains(name)) { menuNames.Add(name, menu.Parent.Name); } else { Console.WriteLine("\tThe menu name '{0}' is used by '{1}' and by '{2}'", name, menu.Parent.Name, menuNames[name]); nErrors++; } } if (menu.IsRealAccessibleObject) { foreach(AccessibilityHelper child in menu) { nErrors += CheckMenuNameShortCutUniqueness(child, shortCuts, menuNames); } } return nErrors; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Recurse the menus to make sure no menus have duplicate hotkeys in the menu items /// </summary> /// <param name="menu">Menu to test</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int CheckMenuHotkeys(AccessibilityHelper menu) { int nErrors = 0; ArrayList rgMenuItems = new ArrayList(20); foreach(AccessibilityHelper child in menu) { rgMenuItems.Add(child); if (child.IsRealAccessibleObject) { nErrors += CheckMenuHotkeys(child); } } for (int id1 = 0; id1 < rgMenuItems.Count; id1++) { AccessibilityHelper child1 = (AccessibilityHelper)rgMenuItems[id1]; if (child1.Role != AccessibleRole.Separator) { for (int id2 = id1+1; id2 < rgMenuItems.Count; id2++) { AccessibilityHelper child2 = (AccessibilityHelper)rgMenuItems[id2]; if (child2.Role != AccessibleRole.Separator && child1.Shortcut == child2.Shortcut && child1.Shortcut != null && child1.Shortcut.Length != 0) { Console.WriteLine("\tThe hotkey '{0}' is used by '{1}' and by '{2}'", child1.Shortcut, child1.Name, child2.Name); nErrors++; } } } } return nErrors; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Recurse the menus to make sure no menus with sub menus contain trailing ellipses /// in the menu text. /// </summary> /// <param name="menu">Menu to test</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int CheckMenuEllipses(AccessibilityHelper menu) { int nErrors = 0; if (menu.Role == AccessibleRole.MenuPopup) { if (menu.Name.Trim().EndsWith("...")) { Console.WriteLine("\tSub menu '{0}' has ellipses in name", menu.Name); nErrors++; } } if (menu.IsRealAccessibleObject) { foreach(AccessibilityHelper child in menu) { nErrors += CheckMenuEllipses(child); } } return nErrors; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Test the menu capitalization and "Book Title" convention /// </summary> /// <param name="menu">Menu to test</param> /// <returns>Number of errors</returns> /// ------------------------------------------------------------------------------------ private int CheckMenuCapitalization(AccessibilityHelper menu) { int nErrors = 0; if (menu.Role != AccessibleRole.Separator && menu.Role != AccessibleRole.MenuPopup && menu.Name != null && menu.Name.Length > 0) { if (!Char.IsUpper(menu.Name[0]) && !Char.IsDigit(menu.Name[0])) { Console.WriteLine("\t'{0}' is not capitalized nor digit", menu.Name); nErrors++; } String[] menuNameParts = menu.Name.Split(new char[] { ' ' }); for(int i = 1; i < menuNameParts.Length; i++) { if (Char.IsLower(menuNameParts[i][0])) { switch(menuNameParts[i]) { case "the": //these are okay case "or": case "and": case "a": case "of": case "in": break; default: // any other lower case is not Console.WriteLine( "\t'{0}' does not follow 'Book Title' convention", menu.Name); nErrors++; break; } } } } if (menu.IsRealAccessibleObject) { foreach(AccessibilityHelper child in menu) { nErrors += CheckMenuCapitalization(child); } } return nErrors; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Loop through all menu items (and sub-menus) of one menu and check help text in the /// status bar. /// </summary> /// <param name="menuParent">The main frame menu <see cref="AccessibilityHelper"/>, e.g. /// for File.</param> /// ------------------------------------------------------------------------------------ protected int CheckStatusbarMenuTexts(AccessibilityHelper menuParent) { int nErrors = 0; // Because we're really opening the menu, we have one additional layer, that is // usually not visible (if you inspect it with AccExplorer, e.g): the window. // This consists also only of 1 child foreach (AccessibilityHelper menuWindow in menuParent) { // There should be only 1 popup menu for the menuParent... foreach (AccessibilityHelper menuPopup in menuWindow) { Debug.WriteLine(string.Format("Menu popup {0} (#children: {1}, role: {2})", menuPopup.Name, menuPopup.ChildCount, menuPopup.Role)); foreach (AccessibilityHelper menuItem in menuPopup) { if (menuItem.Role == AccessibleRole.Separator) Debug.WriteLine("Separator -------"); else { nErrors += CheckMenuHelp(menuItem.Name); if (menuItem.IsRealAccessibleObject) { Debug.WriteLine(string.Format("Sub Menu {0} (role: {1})", menuItem.Name, menuItem.Role)); Debug.WriteLine("{RIGHT}"); m_app.SendKeys("{RIGHT}"); nErrors += CheckStatusbarMenuTexts(menuItem); } else { Debug.WriteLine(string.Format("Menu item {0}", menuItem.Name)); } Debug.WriteLine("{DOWN}"); m_app.SendKeys("{DOWN}"); } } } } Debug.WriteLine("{ESC}"); m_app.SendKeys("{ESC}"); return nErrors; }
///// <summary> ///// Correct way to deal with FixtureTearDown for class that derive from BaseTest. ///// </summary> ///// <param name="disposing"></param> //protected override void Dispose(bool disposing) //{ // if (IsDisposed) // return; // if (disposing) // { // if (m_app != null) // { // m_app.Exit(); // } // } // m_app = null; // m_StatusBar = null; // base.Dispose(disposing); //} /// ------------------------------------------------------------------------------------ /// <summary> /// Loop through all menu items to make sure that they are loaded (some are created /// only when they show, but afterwards they still exist). /// </summary> /// <param name="parent"><see cref="AccessibilityHelper"/> of the main window</param> /// ------------------------------------------------------------------------------------ public void ActivateAllMenuItems(AccessibilityHelper parent) { foreach (AccessibilityHelper child in parent) { if (child.Role == AccessibleRole.MenuBar && child.Name != "System") { m_app.SendKeys("%"); foreach (AccessibilityHelper menu in child) { Debug.WriteLine("----------------------------------------"); Debug.WriteLine(string.Format("Activating main frame menu {0} (Role: {1})", menu.Name, menu.Role)); if (menu.IsRealAccessibleObject) { m_app.SendKeys("{DOWN}"); Debug.WriteLine("{DOWN}"); ActivateThisMenu(menu); } Debug.WriteLine("{RIGHT}"); m_app.SendKeys("{RIGHT}"); } Debug.WriteLine("{ESC}"); m_app.SendKeys("{ESC}"); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Exits the application /// </summary> /// <param name="fOnCurrentWindow">If <c>true</c> send Alt-F4 regardless of what window /// is active. Otherwise switch to the main window first.</param> /// ------------------------------------------------------------------------------------ public void Exit(bool fOnCurrentWindow) { try { m_proc.WaitForInputIdle(); if (!fOnCurrentWindow) Win32.SetForegroundWindow(m_proc.MainWindowHandle); // It works better if we send an ESC first m_proc.Close(); m_proc.WaitForExit(); } catch { } m_proc = null; m_AccHelper = null; }
public override void Init() { base.Init(); Thread.Sleep(500); // Select "File/Import/Standard Format" to bring up the import dialog m_app.SendKeys("%F"); m_app.SendKeys("{DOWN 8}"); m_app.SendKeys("{ENTER}"); m_app.SendKeys("{ENTER}"); Application.DoEvents(); AccessibilityHelper importDlg = m_app.MainAccessibilityHelper.Parent.FindDirectChild("Import Standard Format", AccessibleRole.None); // select the "Import" button which is the default button if (importDlg != null) m_app.SendKeys("{ENTER}"); Application.DoEvents(); m_dialog = m_app.MainAccessibilityHelper.Parent.FindDirectChild( "Import Standard Format", AccessibleRole.None); m_saveRegistryData = Unpacker.PrepareRegistryForPTData(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Check the radio buttons. We should have exactly two: Paratext and Other /// </summary> /// <param name="parent">The element to start with</param> /// <param name="nRbsFound">Number of radio buttons found.</param> /// <remarks>On return <paramref name="nRbsFound"/> should be 2. If there are additional /// radio buttons on the dialog, <paramref name="nRbsFound"/> will return a negative /// number.</remarks> /// ------------------------------------------------------------------------------------ protected void CheckRadioButtons(AccessibilityHelper parent, ref int nRbsFound) { foreach (AccessibilityHelper child in parent) { if ((child.States & AccessibleStates.Invisible) == AccessibleStates.Invisible) continue; if (child.Role == AccessibleRole.RadioButton) { if (child.Name == "Paratext") { // paratext radio button has to be default if paratext is installed RegistryKey regKey = Registry.LocalMachine.OpenSubKey(kPTSettingsRegKey); if (regKey != null) Assert.AreEqual(AccessibleStates.Checked, (child.States & AccessibleStates.Checked), "Paratext is installed, but Paratext radio button " + "is not the default."); nRbsFound++; } else if (child.Name == "Other") { // Other radio button has to be default if Paratext isn't installed RegistryKey regKey = Registry.LocalMachine.OpenSubKey(kPTSettingsRegKey); if (regKey == null) Assert.AreEqual(AccessibleStates.Checked, (child.States & AccessibleStates.Checked), "Paratext is not installed, but Other radio button is not the default."); nRbsFound++; } else nRbsFound = -99; } if (child.IsRealAccessibleObject) CheckRadioButtons(child, ref nRbsFound); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Check the controls on the step and see if there are non-excaptable controls on it, /// i.e. for the overview page return false if there are any check boxes. /// </summary> /// <param name="parent">The element to start with</param> /// <param name="acceptableRoles">Sorted array of acceptable controls</param> /// <returns><c>true</c> if all visible controls are acceptable, otherwise /// <c>false</c>.</returns> /// ------------------------------------------------------------------------------------ protected bool CheckControls(AccessibilityHelper parent, AccessibleRole[] acceptableRoles) { bool fRet = true; foreach (AccessibilityHelper child in parent) { if ((child.States & AccessibleStates.Invisible) == AccessibleStates.Invisible) continue; if (Array.BinarySearch(acceptableRoles, child.Role) < 0) return false; if (child.IsRealAccessibleObject) fRet = CheckControls(child, acceptableRoles); if (!fRet) return fRet; } return fRet; }
public void FindNthChild() { Process proc = m_proc; AccessibilityHelper ah = m_ah; // start second instance Init(); // now look for the second instance int nWhich = 1; AccessibilityHelper first = m_ah.Parent.FindNthChild("dummyTestForm", AccessibleRole.None, ref nWhich, 0); nWhich = 2; AccessibilityHelper second = m_ah.Parent.FindNthChild("dummyTestForm", AccessibleRole.None, ref nWhich, 0); nWhich = 3; AccessibilityHelper none = m_ah.Parent.FindNthChild("dummyTestForm", AccessibleRole.None, ref nWhich, 0); int hwnd1 = m_proc.MainWindowHandle.ToInt32(); int hwnd2 = proc.MainWindowHandle.ToInt32(); int foundHwnd1 = first.HWnd; int foundHwnd2 = second.HWnd; // Close the second instance EndTest(); m_proc = proc; m_ah = ah; // now test that we got the right window. Do this after closing the second // instance, because if it fails the rest of this method isn't executed Assert.AreEqual(hwnd1, foundHwnd1); Assert.AreEqual(hwnd2, foundHwnd2); Assert.IsTrue(hwnd1 != foundHwnd2); Assert.IsNull(none); }