| public GetSupportedPatterns ( ) : System.Windows.Automation.AutomationPattern[] | ||
| return | System.Windows.Automation.AutomationPattern[] | |
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>
/// Creates a debug hint
/// </summary>
/// <param name="owningWindow">The window that owns the hint</param>
/// <param name="hintBounds">The hint bounds</param>
/// <param name="automationElement">The automation element</param>
/// <returns>A debug hint</returns>
private DebugHint CreateDebugHint(IntPtr owningWindow, Rect hintBounds, AutomationElement automationElement)
{
var supportedPatterns = automationElement.GetSupportedPatterns();
var programmaticNames = supportedPatterns.Select(x => x.ProgrammaticName);
if (supportedPatterns.Any())
{
return new DebugHint(owningWindow, hintBounds, programmaticNames.ToList());
}
return null;
}
//Check the patterns that a control must support according to MSDN.
public void PatternChcek (Element e, AutomationElement ae, AutomationPattern[] addStates, AutomationPattern[] invalidState)
{
procedureLogger.Action (string.Format ("Check {0}'s supported patterns.", e));
//Remove the extra patterns from supported patterns list
for (int i = 0; i < invalidState.Length; i++)
if(((System.Collections.IList)e.SupportedPatterns).Contains(invalidState [i]))
e.SupportedPatterns.Remove(invalidState[i]);
//Add necessary patterns to the supported patterns list
for (int j = 0; j < addStates.Length; j++)
e.SupportedPatterns.Add(addStates [j]);
//Get list of actual patterns of this control
AutomationPattern[] actualPatterns = ae.GetSupportedPatterns ();
procedureLogger.ExpectedResult (string.Format ("supported patterns :"));
for (int k = 0; k < actualPatterns.Length; k++)
procedureLogger.ExpectedResult (string.Format ("{0} ", actualPatterns [k]));
//get a list of actual patterns that are missing or extraneous
List<AutomationPattern> missPattern = new List<AutomationPattern>();
List<AutomationPattern> extraPattern = new List<AutomationPattern>();
for (int p = 0; p < e.SupportedPatterns.Count; p++)
if(!(actualPatterns.Contains (e.SupportedPatterns[p])))
missPattern.Add(e.SupportedPatterns[p]);
for (int q = 0; q < actualPatterns.Length; q++)
if(!(e.SupportedPatterns.Contains (actualPatterns[q])))
extraPattern.Add(actualPatterns[q]);
//If missingPatterns and extraPatterns are empty, the test case passes
//otherwise, throw an exception
if(0 != missPattern.Count)
Console.WriteLine("Missing miss actions: ");
for (int n = 0; n < missPattern.Count; n++)
Console.WriteLine(" {0}", missPattern[n]);
Assert.AreEqual(0, missPattern.Count);
if(0 != actualPatterns.Length)
Console.WriteLine("Missing actual actions: ");
for (int m = 0; m < actualPatterns.Length; m++)
Console.WriteLine(" {0}", actualPatterns[m]);
}
private AutomationElement FindFirstChildWithValuePatternSupported(AutomationElement element)
{
if (element.GetSupportedPatterns().Contains(ValuePattern.Pattern))
{
return element;
}
if (element.GetSupportedPatterns().Contains(TextPattern.Pattern))
{
TextPatternRange document =
((TextPattern)Element.GetCurrentPattern(TextPattern.Pattern)).DocumentRange;
AutomationElement[] children = document.GetChildren();
foreach (var child in children)
{
var firstValidChild = FindFirstChildWithValuePatternSupported(child);
if (firstValidChild != null) { return firstValidChild; }
}
}
return null;
}
/// -------------------------------------------------------------------
/// <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));
}
}
public static void AutomationElementGetSupportedPatterns(AutomationElement element)
{
Dump("GetSupportedPatterns()", true, element);
try
{
AutomationPattern[] obj = element.GetSupportedPatterns();
}
catch (Exception exception)
{
VerifyException(element, exception, typeof(ElementNotAvailableException));
}
}
private void writingAvailablePatterns(AutomationElement element)
{
try {
this.richPatterns.Text = "available patterns";
this.richPatterns.Text += "\r\n";
// 20120618 UIACOMWrapper
AutomationPattern[] supportedPatterns =
element.GetSupportedPatterns();
//UIACOM::System.Windows.Automation.AutomationPattern[] supportedPatterns =
// element.GetSupportedPatterns();
if (supportedPatterns != null &&
supportedPatterns.Length > 0) {
for (int i = 0; i < supportedPatterns.Length; i++) {
if (i > 0) {
this.richPatterns.Text += "\r\n";
}
this.richPatterns.Text +=
supportedPatterns[i].ProgrammaticName.Replace("Identifiers.Pattern", "");
}
}
}
catch {}
}
private static void DisplayPattern(AutomationElement automationElement, StringBuilder stringBuilder, string displayPadding)
{
AutomationPattern[] supportedPatterns = automationElement.GetSupportedPatterns();
foreach (AutomationPattern automationPattern in supportedPatterns)
{
var pattern = (BasePattern) automationElement.GetCurrentPattern(automationPattern);
stringBuilder.Append(displayPadding).AppendLine(pattern.ToString());
}
stringBuilder.AppendLine();
}
/// <summary>
/// Gets the most useful pattern from the element to use in the test path.
/// </summary>
/// <param name="rootElement"></param>
/// <returns></returns>
private string getBestPattern(AutomationElement rootElement)
{
string pathImage = "";
AutomationPattern[] aps = rootElement.GetSupportedPatterns();
if (aps.Length == 0) pathImage += "none";
else if (aps.Length == 1) pathImage += aps[0].ProgrammaticName;
else
{
string best = "";
int bestWeight = 9999;
foreach (AutomationPattern ap in aps)
{
int ind = ap.Id - 10000;
int w = bestPattern[ind];
if (w < bestWeight)
{
bestWeight = w;
best = ap.ProgrammaticName;
}
}
pathImage = best;
}
return pathImage.Replace("Pattern", null).Replace("Identifiers.", null) + ":";
}
private ValuePattern SupportsValuePattern(AutomationElement ae)
{
try
{
ValuePattern valpat = (ValuePattern)ae.GetCurrentPattern(ValuePattern.Pattern);
AutomationPattern[] p1 = ae.GetSupportedPatterns();
logTofile(_eLogPtah, "patterns lenght for ae =" + p1.Length);
//for (int jj = 0; jj < p1.Length; jj++)
//{
// }
return valpat;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
// return null;
}
}
private string RetrieveTextFrom(AutomationElement element)
{
string text = string.Empty;
if (element.GetSupportedPatterns().Contains(ValuePattern.Pattern))
{
text = text + new ValuePatternWrapper(element).Value;
}
else if (element.GetSupportedPatterns().Contains(TextPattern.Pattern))
{
TextPatternRange document =
((TextPattern)Element.GetCurrentPattern(TextPattern.Pattern)).DocumentRange;
AutomationElement[] children = document.GetChildren();
foreach (var child in children)
{
text = text + RetrieveTextFrom(child);
}
}
return text;
}
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;
}
private void SupportedPropertiesTestInternal (AutomationElement element)
{
var supportedProperties = element.GetSupportedProperties ();
foreach (AutomationPattern pattern in element.GetSupportedPatterns ()) {
foreach (var prop in GetPatternProperties (pattern)) {
Assert.IsTrue (supportedProperties.Contains (prop),
string.Format ("[{0}] {1} shall be supported since {2} pattern is supported",
element.Current.Name,
prop.ProgrammaticName,
At.PatternName (pattern)));
}
}
foreach (var prop in supportedProperties) {
Assert.AreNotEqual (AutomationElement.NotSupported,
element.GetCurrentPropertyValue (prop, true),
string.Format ("[{0}] {1} shall be supported since it's in SupportedProperties",
element.Current.Name,
prop.ProgrammaticName));
}
}
