internal TextWrapper(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)
{
if (m_le == null)
throw new ArgumentException("m_le cannot be null");
_pattern = (TextPattern)m_le.GetCurrentPattern(TextPattern.Pattern);
_frameworkId = ((string)m_le.GetCurrentPropertyValue(AutomationElement.FrameworkIdProperty)).ToLower(CultureInfo.InvariantCulture);
_testPriority = TestPriorities.BuildVerificationTest; // default value
// Determine if tests currently running on Windows Vista
NativeMethods.OSVERSIONINFOEX ver = new NativeMethods.OSVERSIONINFOEX();
UnsafeNativeMethods.GetVersionEx(ver);
if (ver.majorVersion >= 6) // This should account for Windows Vista + Service Packs
_windowsVista = true; // It may also occur for Vienna, but the expectation is things
else // could change so much post-Vista, that TextPattern tests will
_windowsVista = false; // have to be revisited anyway ((i.e. we will likely be moving to un-managed client)
Comment("Operating System Version = " + ver.majorVersion + "." + ver.minorVersion + "." + ver.buildNumber);
}
private static TextPatternRange GetRandomTestPatternRange(TextPattern pattern)
{
int count = _rnd.Next(-10, 10);
TextUnit textUnit = GetRandomTextUnit();
pattern.DocumentRange.Move(textUnit, count);
count = _rnd.Next(-10, 10);
textUnit = GetRandomTextUnit();
pattern.DocumentRange.MoveEndpointByUnit(TextPatternRangeEndpoint.End, textUnit, count);
return pattern.DocumentRange;
}
// -------------------------------------------------------------------
// Determine if the application we are hitting supports knowledge about the control's text implementation
// -------------------------------------------------------------------
private void TS_ScenarioPreConditions(bool requireTextPattern, CheckType checkType)
{
string className;
string localizedControlType;
// This is hard-coded as a critical failure
if (m_le == null)
{
ThrowMe( CheckType.Verification, "Unable to get AutomationElement for control with focus");
}
// Give info about control
TextLibrary.GetClassName(m_le, out className, out localizedControlType);
Comment("Automation ID = " + m_le.Current.AutomationId.ToString() +
" (" + className + " / " + localizedControlType + ")");
try
{
_pattern = m_le.GetCurrentPattern(TextPattern.Pattern) as TextPattern;
}
catch (Exception exception)
{
if (Library.IsCriticalException(exception))
throw;
Comment("Acquiring TextPattern for automation element with focus raised exception");
Comment(" Message = " + exception.Message);
Comment(" Type = " + exception.GetType().ToString());
ThrowMe(checkType, "Unable to proceed with test, should not have received exception acquiring TextPattern"); // hard-coded... on purpose
}
m_TestStep++;
}
// compare two text patterns and return true if they are from the same logical element.
static internal bool Compare(TextPattern t1, TextPattern t2)
{
return Misc.Compare(t1._element, t2._element);
}
// -------------------------------------------------------------------
// Determine if the application we are hitting supports knowledge about the control's text implementation
// -------------------------------------------------------------------
private void TS_ScenarioPreConditions(bool requireTextPattern, CheckType checkType)
{
string className;
string localizedControlType;
// This is hard-coded as a critical failure
if (m_le == null)
{
ThrowMe(
CheckType.Verification, "Unable to get AutomationElement for control with focus");
}
// Give info about control
GetClassName(m_le, out className, out localizedControlType);
Comment("Automation ID = " + m_le.Current.AutomationId.ToString() +
" (" + className + " / " + localizedControlType + ")");
try
{
_pattern = m_le.GetCurrentPattern(TextPattern.Pattern) as TextPattern;
}
catch (InvalidOperationException)
{
Comment("Unable to get a _textPattern for this control (likely a disabled control)");
supportsText = false;
}
catch (Exception exception)
{
if (Library.IsCriticalException(exception))
throw;
Comment("Acquiring TextPattern for automation element with focus raised exception");
Comment(" Message = " + exception.Message);
Comment(" Type = " + exception.GetType().ToString());
ThrowMe(CheckType.Verification, "Unable to proceed with test, should not have received exception acquiring TextPattern"); // hard-coded... on purpose
}
// Do we have a valid text pattern?
if ((_pattern == null) && (requireTextPattern == true ))
{
ThrowMe(CheckType.Verification, "Unable to proceed with test, should not have received exception acquiring TextPattern"); // hard-coded... on purpose
}
// Would be nice to have this information.
if (m_le.Current.AutomationId.ToString().Length == 0)
{
ThrowMe(checkType, "Unable to determine automation id of control");
}
m_TestStep++;
}
/// --------------------------------------------------------------------
/// <summary>
/// Finds the text control in our target.
/// </summary>
/// <param name="src">The object that raised the event.</param>
/// <param name="e">Event arguments.</param>
/// <remarks>
/// Initializes the TextPattern object and event handlers.
/// </remarks>
/// --------------------------------------------------------------------
private void FindTextProvider_Click(object src, RoutedEventArgs e)
{
// Set up the conditions for finding the text control.
var documentControl = new PropertyCondition(
AutomationElement.ControlTypeProperty,
ControlType.Document);
var textPatternAvailable = new PropertyCondition(
AutomationElement.IsTextPatternAvailableProperty, true);
var findControl =
new AndCondition(documentControl, textPatternAvailable);
// Get the Automation Element for the first text control found.
// For the purposes of this sample it is sufficient to find the
// first text control. In other cases there may be multiple text
// controls to sort through.
_targetDocument =
_targetWindow.FindFirst(TreeScope.Descendants, findControl);
// Didn't find a text control.
if (_targetDocument == null)
{
_targetResult.Content =
_wpfTarget +
" does not contain a Document control type.";
_targetResult.Background = Brushes.Salmon;
_startWpfTargetButton.IsEnabled = false;
return;
}
// Get required control patterns
_targetTextPattern =
_targetDocument.GetCurrentPattern(
TextPattern.Pattern) as TextPattern;
// Didn't find a text control that supports TextPattern.
if (_targetTextPattern == null)
{
_targetResult.Content =
_wpfTarget +
" does not contain an element that supports TextPattern.";
_targetResult.Background = Brushes.Salmon;
_startWpfTargetButton.IsEnabled = false;
return;
}
// Text control is available so display the client controls.
_infoGrid.Visibility = Visibility.Visible;
_targetResult.Content =
"Text provider found.";
_targetResult.Background = Brushes.LightGreen;
// Initialize the document range for the text of the document.
_documentRange = _targetTextPattern.DocumentRange;
// Initialize the client's search buttons.
if (_targetTextPattern.DocumentRange.GetText(1).Length > 0)
{
_searchForwardButton.IsEnabled = true;
}
// Initialize the client's search TextBox.
_searchString.IsEnabled = true;
// Check if the text control supports text selection
if (_targetTextPattern.SupportedTextSelection ==
SupportedTextSelection.None)
{
_targetResult.Content = "Unable to select text.";
_targetResult.Background = Brushes.Salmon;
return;
}
// Edit control found so remove the find button from the client.
_findEditButton.Visibility = Visibility.Collapsed;
// Initialize the client with the current target selection, if any.
NotifySelectionChanged();
// Search starts at beginning of doc and goes forward
_searchBackward = false;
// Initialize a text changed listener.
// An instance of TextPatternRange will become invalid if
// one of the following occurs:
// 1) The text in the provider changes via some user activity.
// 2) ValuePattern.SetValue is used to programatically change
// the value of the text in the provider.
// The only way the client application can detect if the text
// has changed (to ensure that the ranges are still valid),
// is by setting a listener for the TextChanged event of
// the TextPattern. If this event is raised, the client needs
// to update the targetDocumentRange member data to ensure the
// user is working with the updated text.
// Clients must always anticipate the possibility that the text
// can change underneath them.
Automation.AddAutomationEventHandler(
TextPattern.TextChangedEvent,
_targetDocument,
TreeScope.Element,
TextChanged);
// Initialize a selection changed listener.
// The target selection is reflected in the client.
Automation.AddAutomationEventHandler(
TextPattern.TextSelectionChangedEvent,
_targetDocument,
TreeScope.Element,
OnTextSelectionChange);
}
//---------------------------------------------------------------------------
// TestStep for TextPatternRange.TextPattern property
//---------------------------------------------------------------------------
static internal void TS_IsMatchingTextPattern(TextPattern _pattern, TextPattern newPattern, CheckType checkType)
{
if (ReferenceEquals(_pattern, newPattern) == true)
Comment("TextPattern property matches expected instance of TextPattern class");
else
ThrowMe(
checkType, "TextPattern property does not match expected instance of TextPattern class");
m_TestStep++;
}
//---------------------------------------------------------------------------
// TestStep for TextPatternRange.TextPattern Property
//---------------------------------------------------------------------------
static internal void TS_TextPattern(TextPatternRange range, ref TextPattern pattern, CheckType checkType)
{
Range_TextPattern(range, ref pattern);
if (pattern == null)
ThrowMe(checkType, "TextPatternRange.TextPattern property should not return NULL");
m_TestStep++;
}
//---------------------------------------------------------------------------
// Wrapper for TextPatternRange.TextPattern Property
//---------------------------------------------------------------------------
static internal void Range_TextPattern(TextPatternRange callingRange, ref TextPattern pattern)
{
string call = "TextPatternRange.TextPattern";
Comment("---Getting value of " + call);
if (callingRange == null)
throw new ArgumentNullException(call + " requires non-NULL TextPatterncallingRange");
pattern = callingRange.TextPattern;
}
//---------------------------------------------------------------------------
// Wrapper for TextPattern.GetVisibleRanges Method
//---------------------------------------------------------------------------
internal void Pattern_GetVisibleRanges(TextPattern textPattern, ref TextPatternRange[] returnedRanges, Type expectedException, CheckType checkType)
{
string call = "TextPattern.GetVisibleRanges()";
Comment("---Calling " + call);
try
{
returnedRanges = textPattern.GetVisibleRanges();
}
catch (Exception actualException)
{
if (Library.IsCriticalException(actualException))
throw;
TestException(expectedException, actualException, call, checkType);
return;
}
if (returnedRanges == null)
ThrowMe(checkType, call + " should not give a null TextPatternRange");
TestNoExceptionQuiet(expectedException, call, checkType);
}
//---------------------------------------------------------------------------
// Wrapper for TextPattern.RangeFromChild Method
//---------------------------------------------------------------------------
internal void Pattern_RangeFromChild(TextPattern textPattern, ref TextPatternRange returnedRange, AutomationElement childElem, Type expectedException, CheckType checkType)
{
string call = "TextPattern.RangeFromChild(" + childElem + ")";
Comment("---Calling " + call);
try
{
returnedRange = textPattern.RangeFromChild(childElem);
}
catch (Exception actualException)
{
if (Library.IsCriticalException(actualException))
throw;
if( (actualException is ArgumentException) || (actualException is InvalidOperationException))
{
// Win32 Edit Controls don't support children. InvalidOperationException here is expected
if ((TextLibrary.typeOfProvider == "win32") || (TextLibrary.typeOfProvider == "winform"))
{
if ((childElem != null) && (TextLibrary.IsRichEdit(childElem) == false))
{
// Yes, this is a hard-coded CheckType. This is by-design/a good thing
ThrowMe(CheckType.IncorrectElementConfiguration, "Win32 Edit controls do not support children");
}
}
}
TestException(expectedException, actualException, call, checkType);
return;
}
if (returnedRange == null)
ThrowMe(checkType, call + " should not give a null TextPatternRange");
TestNoExceptionQuiet(expectedException, call, checkType);
}
//---------------------------------------------------------------------------
// Wrapper for TextPattern.RangeFromPoint Method
//---------------------------------------------------------------------------
internal void Pattern_RangeFromPoint(TextPattern textPattern, ref TextPatternRange returnedRange, Point screenLocation, Type expectedException, CheckType checkType)
{
string call = "TextPattern.RangeFromPoint(" + screenLocation + ")";
Comment("---Calling " + call);
try
{
returnedRange = textPattern.RangeFromPoint(screenLocation);
}
catch (Exception actualException)
{
if (Library.IsCriticalException(actualException))
throw;
TestException(expectedException, actualException, call, checkType);
return;
}
if (returnedRange == null)
throw new ArgumentNullException(call + " should not give a null TextPatternRange");
TestNoExceptionQuiet(expectedException, call, checkType);
}
// compare two text patterns and return true if they are from the same logical element.
static internal bool Compare(TextPattern t1, TextPattern t2)
{
return(Misc.Compare(t1._element, t2._element));
}
