UI Automation By Microsoft

Getting start with UI test automation using the new Microsoft UI Automation library, UIWalker.dll is written by Qijie Xue (qijiexue@outlook.com). Feel free to use below codes in your UI automation testing, please mark where you get this codes if you'd like to re-post.

using System;
using System.Collections.Generic;
using System.Windows.Automation;
using System.Diagnostics;
using System.Threading;

///By Qijie Xue on 4.10.2013
namespace UIWalker
{
    public class UIApp
    {
        /// <summary>
        /// Start Executable Application
        /// </summary>
        /// <param name="args">.exe or .msi file</param>
        /// <returns>Application Process</returns>
        public static Process StartApp(string args)
        {
            string appString = string.Empty;
            appString = args;

            Process proc=Process.Start(appString);
            Thread .Sleep (2000);
            return proc;
            //using (Process appProcess = new Process())
            //{                
            //    appProcess.StartInfo.FileName = appString;
            //    appProcess.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
            //    appProcess.Start();
            //    Thread.Sleep(2000);

            //    return appProcess;
            //}
        }
    }

    public class UIEngine
    {
        static List<UIStruct> Elements = new List<UIStruct>();
        static List<AutomationElement> MenusElements = new List<AutomationElement>();

        /// <summary>
        /// Fetch all UI Elements in the window
        /// </summary>
        /// <param name="window">main window</param>
        /// <param name="recurse">whether fetch by recurse</param>
        /// <returns>a list of elements as UIStruc</returns>
        public static List<UIStruct> FetchElements(AutomationElement window, bool recurse)
        {
            FetchElements(window, recurse, 0);
            if (Elements != null)
            {
                return Elements;
            }
            else
                return null;
        }

        private static void FetchElements(AutomationElement ae, bool recurse, int level)
        {
            if (ae != null)
            {
                Elements.Add(new UIStruct(ae, level));
            }

            if (recurse)
            {
                foreach (AutomationElement item in ae.FindAll (TreeScope.Children ,Condition.TrueCondition))
                {
                    FetchElements(item, recurse, level + 1);
                }
            }
        }

        /// <summary>
        /// Fetch menus in the window
        /// </summary>
        /// <param name="window">main window</param>
        /// <returns>top menus as AutomatinElement</returns>
        public static List<AutomationElement> FetchMenus(AutomationElement window)
        {
            AutomationElementCollection menusBars = window.FindAll(TreeScope.Children, new PropertyCondition(
                AutomationElement.ControlTypeProperty, ControlType.MenuBar));
            if (menusBars.Count == 0)
                return null;
            AutomationElement mainMenuItem = menusBars[0];
            AutomationElementCollection menus = mainMenuItem.FindAll(TreeScope.Children, new PropertyCondition(
                AutomationElement.ControlTypeProperty, ControlType.MenuItem));
            if (menus.Count == 0)
                return null;

            for (int i = 0; i < menus.Count; i++)
            {
                MenusElements.Add(menus[i]);
            }

            return MenusElements;
        }
    }

    public class UIAction
    {
        public static void SetSelectedComboBoxItem(AutomationElement comboBox, string item)
        {
            if (comboBox.Current.ControlType == ControlType.ComboBox)
            {
                AutomationPattern automationPatternFromElement = GetSpecifiedPattern(comboBox, "ExpandCollapsePatternIdentifiers.Pattern");

                ExpandCollapsePattern expandCollapsePattern = comboBox.GetCurrentPattern(automationPatternFromElement) as ExpandCollapsePattern;

                expandCollapsePattern.Expand();
                expandCollapsePattern.Collapse();

                AutomationElement listItem = comboBox.FindFirst(TreeScope.Subtree, new PropertyCondition(AutomationElement.NameProperty, item));

                automationPatternFromElement = GetSpecifiedPattern(listItem, "SelectionItemPatternIdentifiers.Pattern");

                SelectionItemPattern selectionItemPattern = listItem.GetCurrentPattern(automationPatternFromElement) as SelectionItemPattern;

                selectionItemPattern.Select();
            }
        }

        private static AutomationPattern GetSpecifiedPattern(AutomationElement element, string patternName)
        {
            AutomationPattern[] supportedPattern = element.GetSupportedPatterns();

            foreach (AutomationPattern pattern in supportedPattern)
            {
                if (pattern.ProgrammaticName == patternName)
                    return pattern;
            }

            return null;
        }

        /// <summary>
        /// Invoke item in menu
        /// </summary>
        /// <param name="menu">top menu item</param>
        /// <param name="item">the item to invoke in the menu</param>
        public static void SelectMenu(AutomationElement menu, string item)
        {
            AutomationPattern automationPatternFromElement = GetSpecifiedPattern(menu, "InvokePatternIdentifiers.Pattern");

            if (automationPatternFromElement != null)
            {
                InvokePattern invokeItemPattern = menu.GetCurrentPattern(automationPatternFromElement) as InvokePattern;
                invokeItemPattern.Invoke();

                //ExpandCollapsePattern expandCollapsePattern = menu.GetCurrentPattern(ExpandCollapsePattern.Pattern) as ExpandCollapsePattern;

                //expandCollapsePattern.Expand();
                //expandCollapsePattern.Collapse();

                System.Threading.Thread.Sleep(2000);

                AutomationElement menuItem = menu.FindFirst(TreeScope.Subtree, new PropertyCondition(AutomationElement.NameProperty, item));
                automationPatternFromElement = GetSpecifiedPattern(menuItem, "InvokePatternIdentifiers.Pattern");
                if (automationPatternFromElement != null)
                {
                    //SelectionItemPattern selectionItemPattern = menu.GetCurrentPattern(automationPatternFromElement) as SelectionItemPattern;

                    //selectionItemPattern.Select();

                    invokeItemPattern = menuItem.GetCurrentPattern(automationPatternFromElement) as InvokePattern;
                    invokeItemPattern.Invoke();
                }
            }
        }

        public static void ClickButton(AutomationElement button)
        {
            AutomationPattern automationPatternFromElement = GetSpecifiedPattern(button, "InvokePatternIdentifiers.Pattern");
            if (automationPatternFromElement != null)
            {
                InvokePattern invokeItemPattern = button.GetCurrentPattern(automationPatternFromElement) as InvokePattern;
                invokeItemPattern.Invoke();
                Thread.Sleep(1000);
            }
        }

        public static void SetValue(AutomationElement textBox, string value)
        {
            if (textBox.Current.ControlType == ControlType.Edit)
            {
                ValuePattern valuePattern = (ValuePattern)textBox.GetCurrentPattern(ValuePattern.Pattern);
                valuePattern.SetValue(value);
            }
        }

        public static void SelectRadioBox(AutomationElement radioBox)
        {
            if (radioBox.Current.ControlType == ControlType.RadioButton) ;
            {
                SelectionItemPattern radioButtonPattern = (SelectionItemPattern)radioBox.GetCurrentPattern(SelectionItemPattern.Pattern);
                radioButtonPattern.Select();
            }
        }

        public static string GetTextBoxValue(AutomationElement textBox)
        {
            if (textBox.Current.ControlType == ControlType.Edit)
            {
                TextPattern textPattern = (TextPattern)textBox.GetCurrentPattern(TextPattern.Pattern);
                string result = textPattern.DocumentRange.GetText(-1);
                if (result == null)
                {
                    result = string.Empty;
                }
                return result;
            }
            else
                return string.Empty;
        }

        public static void CloseForm(AutomationElement window)
        {
            if (window.Current.ControlType == ControlType.Window)
            {
                WindowPattern windowPattern = (WindowPattern)window.GetCurrentPattern(WindowPattern.Pattern);
                windowPattern.Close(); 
            }
        }
    }

    public class UIStruct
    {
        public AutomationElement  Element { get; set; }
        public int Level { get; set; }

        public UIStruct(AutomationElement ae, int level)
        {
            this.Element = ae;
            this.Level = level;
        }
    }
}