public static AutomationElement FindChildByControlType(this AutomationElement element, ControlType controlType)
        {
            AutomationElement result =
                element.FindChildByCondition(new PropertyCondition(AutomationElement.ControlTypeProperty, controlType));

            return result;
        }

 /// <summary>
 /// Get automationelement by name, filtered by classname - mouse click if found
 /// </summary>
 /// <param name="parent"></param>
 /// <param name="automationName">case-insensitive automation name</param>
 /// <param name="controlType"></param>
 /// <param name="controlType2"></param>
 /// <exception cref="ApplicationException">if matching element not found</exception>
 /// <exception cref="ApplicationException">if specified element is not enabled</exception>
 public static void FindElementByNameFilteredByControlTypeAndMouseClick(AutomationElement parent, string automationName, ControlType controlType, ControlType controlType2, TimeSpan mouseClickDelay, TreeScope treeScope)
 {
     FindElementByNameFilteredByControlTypeWithTimeoutAndMouseClick(parent, automationName, controlType, controlType2,
             AddinTestUtility.FindRibbonButtonsTimeout, //findDelay
             mouseClickDelay,
             treeScope);
 }

        private void TestParametersAgainstCollection(
            ControlType controlType,
            string searchString,
            IEnumerable<IUiElement> collection,
            int expectedNumberOfElements)
        {
            // Arrange
            string controlTypeString = string.Empty;
            if (null != controlType) {
                controlTypeString = controlType.ProgrammaticName.Substring(12);
            }
            
            GetControlCmdletBase cmdlet =
                FakeFactory.Get_GetControlCmdletBase(controlType, searchString);
            Condition condition =
                ControlSearcher.GetTextSearchCondition(searchString, new string[]{ controlTypeString }, false);
            IUiElement element =
                FakeFactory.GetElement_ForFindAll(
                    collection,
                    condition);
            
            // Act
            var resultList = RealCodeCaller.GetResultList_TextSearch(element, condition);
            
            // Assert
            MbUnit.Framework.Assert.Count(expectedNumberOfElements, resultList);
            Xunit.Assert.Equal(expectedNumberOfElements, resultList.Count);
            if (!string.IsNullOrEmpty(searchString)) {
                MbUnit.Framework.Assert.ForAll(
                    resultList.Cast<IUiElement>().ToList<IUiElement>(),
                    // 20140312
//                    x => x.Current.Name == searchString || x.Current.AutomationId == searchString || x.Current.ClassName == searchString ||
                    x => x.GetCurrent().Name == searchString || x.GetCurrent().AutomationId == searchString || x.GetCurrent().ClassName == searchString ||
                    (null != (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern) && (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern).Current.Value == searchString));
                /*
                (null != (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern) ? 
                     // (x.GetCurrentPattern<IValuePattern, ValuePattern>(ValuePattern.Pattern) as IValuePattern).Current.Value == searchString : 
                     (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern).Current.Value == searchString : 
                     false));
                */
            }
//            if (null != controlType) {
//                MbUnit.Framework.Assert.ForAll(resultList.Cast<IUiElement>().ToList<IUiElement>(), x => x.Current.ControlType == controlType);
//            }
            
            Xunit.Assert.Equal(expectedNumberOfElements, resultList.Count);
            if (!string.IsNullOrEmpty(searchString)) {
                resultList.All(
                    // 20140312
                    // x => x.Current.Name == searchString || x.Current.AutomationId == searchString || x.Current.ClassName == searchString ||
                    x => x.GetCurrent().Name == searchString || x.GetCurrent().AutomationId == searchString || x.GetCurrent().ClassName == searchString ||
                    (null != (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern) && (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern).Current.Value == searchString));
                /*
                (null != (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern) ?
                     (x.GetCurrentPattern<IValuePattern>(ValuePattern.Pattern) as IValuePattern).Current.Value == searchString :
                     false));
                */
            }
            
        }

 public static AutomationElement ThrowInvalidOperationExceptionIfNotOf(this AutomationElement automationElement, ControlType controlType)
 {
     if (!automationElement.Current.ControlType.Equals(controlType))
         throw new InvalidOperationException(string.Format("The AutomationElement provided has the ControlType '{0}', which is not a '{1}'.", 
                                                           automationElement.Current.ControlType, controlType));
     return automationElement;
 }

        public static AutomationElement getAutomationElement(AutomationElement parent, TreeScope scope, ControlType type, string name)
        {
            var element = parent.FindFirst(scope, new AndCondition(
                new PropertyCondition(AutomationElement.ControlTypeProperty, type),
                new PropertyCondition(AutomationElement.NameProperty, name),
                Automation.ControlViewCondition));

            return element;
        }

 public static AutomationElement FindFirstAncestorByControlType(this AutomationElement ae, ControlType className)
 {
     var ancestor = TreeWalker.ControlViewWalker.GetParent(ae);
      for (; ancestor != null && className != ancestor.GetCurrentPropertyValue(AutomationElement.ControlTypeProperty);
     ancestor = TreeWalker.ControlViewWalker.GetParent(ancestor))
      {
      }
      return ancestor;
 }

        public static AutomationElement FindWindowByName(AutomationElement rootElement, string name, ControlType type)
        {
            PropertyCondition nameCondition = new PropertyCondition(AutomationElement.NameProperty, name);

            PropertyCondition typeCondition = new PropertyCondition(AutomationElement.ControlTypeProperty, type);

            AndCondition andCondition = new AndCondition(nameCondition, typeCondition);

            return rootElement.FindFirst(TreeScope.Element | TreeScope.Descendants, andCondition);
        }

        public static AutomationElement FindElementById(AutomationElement parentElement, string automationID, ControlType type)
        {
            PropertyCondition typeCondition = new PropertyCondition(AutomationElement.ControlTypeProperty, type);

            PropertyCondition IDCondition = new PropertyCondition(AutomationElement.AutomationIdProperty, automationID);

            AndCondition andCondition = new AndCondition(typeCondition, IDCondition);

            return parentElement.FindFirst(TreeScope.Element | TreeScope.Descendants, andCondition);
        }

        public static Condition ByTypeAndName(ControlType type, String name)
        {
            Condition[] locators =
            {
                new PropertyCondition(AutomationElement.NameProperty, name),
                new PropertyCondition(AutomationElement.ControlTypeProperty, type)
            };

            return new AndCondition(locators);
        }

        public static AutomationElementCollection FindElementByClassName(AutomationElement parentElement, string className, ControlType type)
        {
            PropertyCondition typeCondition = new PropertyCondition(AutomationElement.ControlTypeProperty, type);

            PropertyCondition IDCondition = new PropertyCondition(AutomationElement.ClassNameProperty, className);

            AndCondition andCondition = new AndCondition(typeCondition, IDCondition);

            return parentElement.FindAll(TreeScope.Element | TreeScope.Descendants, andCondition);
        }

 public static AutomationElement FindInDepth(this AutomationElement root, ControlType type, int levels)
 {
     AutomationElement result = root;
     for (int i = 0; i < levels; i++)
     {
         Thread.Sleep(100);
         result = result.FindFirst(TreeScope.Children, new PropertyCondition(AutomationElement.ControlTypeProperty, type));
     }
     return result;
 }

 public ControlDictionaryItem(Type testControlType, ControlType controlType, string className, bool identifiedByClassName, bool isPrimary,
                              bool isExcluded, string frameworkId, bool hasPrimaryChildren)
 {
     this.testControlType = testControlType;
     this.controlType = controlType;
     this.className = className;
     this.identifiedByClassName = identifiedByClassName;
     this.isPrimary = isPrimary;
     this.isExcluded = isExcluded;
     this.frameworkId = frameworkId;
     this.hasPrimaryChildren = hasPrimaryChildren;
 }

 public int SetTextValue(String windowName, String objName, String value)
 {
     AutomationElement childHandle = GetObjectHandle(windowName,
         objName);
     if (!utils.IsEnabled(childHandle))
     {
         childHandle = null;
         throw new XmlRpcFaultException(123,
             "Object state is disabled");
     }
     object valuePattern = null;
     try
     {
         if (childHandle.Current.ControlType == ControlType.ComboBox)
         {
             AutomationElement o = null;
             ArrayList objectList = new ArrayList();
             ControlType[] type = new ControlType[1] { ControlType.Edit };
             // NOTE: Using "*" for object name, which returns the first
             // matching Edit control type
             o = utils.InternalGetObjectHandle(childHandle,
                 "*", type, ref objectList);
             if (o != null)
                 childHandle = o;
             objectList = null;
         }
         // Reference: http://msdn.microsoft.com/en-us/library/ms750582.aspx
         if (!childHandle.TryGetCurrentPattern(ValuePattern.Pattern,
             out valuePattern))
         {
             childHandle.SetFocus();
             SendKeys.SendWait(value);
         }
         else
             ((ValuePattern)valuePattern).SetValue(value);
     }
     catch (Exception ex)
     {
         LogMessage(ex);
         if (ex is XmlRpcFaultException)
             throw;
         else
             throw new XmlRpcFaultException(123,
                 "Unhandled exception: " + ex.Message);
     }
     finally
     {
         childHandle = null;
         valuePattern = null;
     }
     return 1;
 }

 /// <summary>
 /// This method gets the list of ChildElements of the control type in the Window.
 /// </summary>
 /// <param name="type">Control type</param>       
 public static bool GetChildElement(ControlType type)
 {
     try
     {
         CommonHelperMethods.GetElement(AutomationElement.RootElement, type);
         return true;
     }
     catch (ElementNotAvailableException ex)
     {
         Console.WriteLine(ex);
         return false;
     }
 }

 private AutomationElement GetObjectHandle(string windowName,
     string objName)
 {
     ControlType[] type = new ControlType[1] { ControlType.ScrollBar };
     try
     {
         return utils.GetObjectHandle(windowName, objName, type);
     }
     finally
     {
         type = null;
     }
 }

 private AutomationElement GetObjectHandle(string windowName,
     string objName)
 {
     ControlType[] type = new ControlType[3] { ControlType.ComboBox,
         ControlType.ListItem, ControlType.List/*, ControlType.Text */ };
     try
     {
         return utils.GetObjectHandle(windowName, objName, type);
     }
     finally
     {
         type = null;
     }
 }

 /// <summary>
 /// This method returns an element searched by its control type from the tree.
 /// </summary>
 /// <param name="root">Root Element of the control</param>
 /// <param name="controlType">Control Type of the element</param>
 /// <returns>Automation Element of teh control</returns>
 public static AutomationElement GetElement(AutomationElement root, ControlType controlType)
 {
     if (root == null)
     {
         throw new ArgumentNullException("root");
     }
     if (controlType == null)
     {
         throw new ArgumentNullException("controlType");
     }
     else
     {
         PropertyCondition condType = new PropertyCondition(AutomationElement.ControlTypeProperty, controlType);
         return root.FindFirst(TreeScope.Descendants, condType);
     }
 }

 private AutomationElement GetObjectHandle(string windowName,
     string objName)
 {
     // Pane added for a bug in QT
     // Ref: https://cobra.codeplex.com/discussions/450296
     ControlType[] type = new ControlType[4] { ControlType.Edit,
         ControlType.Document, ControlType.ComboBox, ControlType.Pane };
     try
     {
         return utils.GetObjectHandle(windowName, objName, type);
     }
     finally
     {
         type = null;
     }
 }

 public int DoesRowExist(String windowName, String objName,
     String text, bool partialMatch = false)
 {
     if (String.IsNullOrEmpty(text))
     {
         LogMessage("Argument cannot be empty.");
         return 0;
     }
     ControlType[] type;
     AutomationElement childHandle;
     AutomationElement elementItem;
     try
     {
         childHandle = GetObjectHandle(windowName,
             objName, null, false);
         if (!utils.IsEnabled(childHandle))
         {
             childHandle = null;
             LogMessage("Object state is disabled");
             return 0;
         }
         childHandle.SetFocus();
         type = new ControlType[4] { ControlType.TreeItem,
             ControlType.ListItem, ControlType.DataItem,
             ControlType.Custom };
         if (partialMatch)
             text += "*";
         elementItem = utils.GetObjectHandle(childHandle,
             text, type, false);
         if (elementItem != null)
         {
             return 1;
         }
     }
     catch (Exception ex)
     {
         LogMessage(ex);
     }
     finally
     {
         type = null;
         childHandle = elementItem = null;
     }
     return 0;
 }

 private AutomationElement GetObjectHandle(string windowName,
     string objName, ControlType[] type = null, bool waitForObj = true)
 {
     if (type == null)
         type = new ControlType[6] { ControlType.Tree,
             ControlType.List, ControlType.Table,
             ControlType.DataItem, ControlType.ListItem,
             ControlType.TreeItem };
     try
     {
         return utils.GetObjectHandle(windowName,
             objName, type, waitForObj);
     }
     finally
     {
         type = null;
     }
 }