/// <summary>
/// Sets the current value of the UI Automation element
/// </summary>
/// <param name="control">The UI Automation element.</param>
/// <param name="value">The value to set the control to.</param>
internal static void SetValue(AutomationElement control, double value)
{
RangeValuePattern pattern = (RangeValuePattern)CommonUIAPatternHelpers.CheckPatternSupport(RangeValuePattern.Pattern, control);
pattern.SetValue(value);
ValueVerifier <double, double> .Verify(value, GetValue(control));
}
public void SetPosition(int hwnd, double pos)
{
AutomationElement element = Find(hwnd);
RangeValuePattern range = element.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
range.SetValue(pos);
}
public void RangeValueTest()
{
RangeValuePattern pattern = null;
if (Atspi)
{
pattern = (RangeValuePattern)numericUpDown1Element.GetCurrentPattern(RangeValuePatternIdentifiers.Pattern);
Assert.AreEqual(0, pattern.Current.Minimum, "RangeValue Minimum");
Assert.AreEqual(100, pattern.Current.Maximum, "RangeValue Maximum");
Assert.AreEqual(10, pattern.Current.SmallChange, "RangeValue SmallChange");
}
else
{
//on Windows Winform, NumericUpDown's RangeValuePattern isn't well implemented
//So we choose to test RangeValuePattern on textBox3's Horzontal Scroll Bar
pattern = (RangeValuePattern)hScrollBarElement.GetCurrentPattern(RangeValuePattern.Pattern);
var min = pattern.Current.Minimum;
var max = pattern.Current.Maximum;
Assert.AreEqual(0, min, "RangeValue Minimum");
Assert.Greater(max, min, "Maximum > Minimum");
Assert.AreEqual(0, pattern.Current.Value, "RangeValue Value");
Assert.AreEqual(1, pattern.Current.SmallChange, "RangeValue SmallChange");
}
pattern.SetValue(50);
Assert.AreEqual(50, pattern.Current.Value, "RangeValue Value after set");
try {
pattern.SetValue(500);
Assert.Fail("Should throw ArgumentOutOfRangeException");
}
catch (ArgumentOutOfRangeException) { }
Assert.AreEqual(50, pattern.Current.Value, "RangeValue Value after OOR set");
}
public void RangeValuePatternCachedTest()
{
using (AppHost host = new AppHost("rundll32.exe", "shell32.dll,Control_RunDLL main.cpl ,2"))
{
CacheRequest req = new CacheRequest();
req.Add(RangeValuePattern.Pattern);
req.Add(RangeValuePattern.IsReadOnlyProperty);
req.Add(RangeValuePattern.MaximumProperty);
req.Add(RangeValuePattern.MinimumProperty);
req.Add(RangeValuePattern.SmallChangeProperty);
req.Add(RangeValuePattern.LargeChangeProperty);
using (req.Activate())
{
// Find a well-known slider
AutomationElement slider = host.Element.FindFirst(TreeScope.Subtree,
new PropertyCondition(AutomationElement.AutomationIdProperty, "101"));
Assert.IsNotNull(slider);
RangeValuePattern range = (RangeValuePattern)slider.GetCachedPattern(RangeValuePattern.Pattern);
double originalValue = range.Cached.Value;
Assert.IsTrue(range.Cached.SmallChange >= 0);
Assert.IsTrue(range.Cached.LargeChange >= 0);
Assert.IsTrue(originalValue >= range.Cached.Minimum);
Assert.IsTrue(originalValue <= range.Cached.Maximum);
Assert.IsFalse(range.Cached.IsReadOnly);
}
}
}
public double GetLargeStep(int hwnd)
{
AutomationElement element = Find(hwnd);
RangeValuePattern range = element.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
return(range.Current.LargeChange);
}
public void Z_NotEnabledTest()
{
RangeValuePattern pattern = null;
if (Atspi)
{
DisableControls();
pattern = (RangeValuePattern)numericUpDown1Element.GetCurrentPattern(RangeValuePatternIdentifiers.Pattern);
try {
pattern.SetValue(50);
Assert.Fail("Should throw ElementNotEnabledException");
} catch (ElementNotEnabledException) { }
EnableControls();
}
else
{
RunCommand("disable textBox3");
try {
hScrollBarElement = textbox3Element.FindFirst(TreeScope.Children, horizontalScrollCondition);
Assert.IsNotNull(hScrollBarElement);
pattern = (RangeValuePattern)hScrollBarElement.GetCurrentPattern(RangeValuePattern.Pattern);
Assert.Fail("Should throw InvalidOperationException " +
"to indicate that disabled scrollBar dosen't support RangeValuePattern");
} catch (InvalidOperationException) { }
}
}
public double GetLowerBound(int hwnd)
{
AutomationElement element = GetElement(hwnd);
RangeValuePattern range = element.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
return(range.Current.Minimum);
}
public double GetUpperBound(int hwnd)
{
AutomationElement element = Find(hwnd);
RangeValuePattern range = element.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
return(range.Current.Maximum);
}
/// <summary>
/// Constructor.
/// </summary>
public UIARangeValuePattern_snippets()
{
AutomationElement targetWindow =
StartTargetApp(System.Windows.Forms.Application.StartupPath +
"\\RangeValuePattern_snip_Target.exe");
targetControl = FindAutomationElement(targetWindow);
RangeValuePattern rangeValuePattern =
GetRangeValuePattern(targetControl[0]);
object d = GetRangeValueProperty(rangeValuePattern, RangeValuePattern.LargeChangeProperty);
// <Snippet103SmallChange>
SetRangeValue(targetControl[0], rangeValuePattern.Current.SmallChange, 1);
// </Snippet103SmallChange>
// <Snippet103LargeChange>
SetRangeValue(targetControl[0], rangeValuePattern.Current.LargeChange, -1);
// </Snippet103LargeChange>
// <Snippet104Minimum>
SetRangeValue(targetControl[0], rangeValuePattern.Current.Minimum);
// </Snippet104Minimum>
// <Snippet104Maximum>
SetRangeValue(targetControl[0], rangeValuePattern.Current.Maximum);
// </Snippet104Maximum>
}
// </Snippet103>
// <Snippet104>
///--------------------------------------------------------------------
/// <summary>
/// Sets the range value of the control of interest.
/// </summary>
/// <param name="targetControl">
/// The automation element of interest.
/// </param>
/// <param name="rangeValue">
/// The value (either relative or absolute) to set the control to.
/// </param>
///--------------------------------------------------------------------
private void SetRangeValue(
AutomationElement targetControl,
double rangeValue)
{
if (targetControl == null)
{
throw new ArgumentException("Argument cannot be null.");
}
RangeValuePattern rangeValuePattern =
GetRangeValuePattern(targetControl);
if (rangeValuePattern.Current.IsReadOnly)
{
throw new InvalidOperationException("Control is read-only.");
}
try
{
rangeValuePattern.SetValue(rangeValue);
}
catch (ArgumentOutOfRangeException)
{
// TO DO: Error handling.
}
catch (ArgumentException)
{
// TO DO: Error handling.
}
}
public void SetValue(int hwnd, double newVal)
{
AutomationElement element = Find(hwnd);
RangeValuePattern value = element.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
value.SetValue(newVal);
}
public double GetPosition(int hwnd)
{
AutomationElement element = Find(hwnd);
RangeValuePattern range = element.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
return(range.Current.Value);
}
private void RangeValuePatternController()
{
RangeValuePattern rangeValuePattern = (RangeValuePattern)PatternObject;
if (MethodType == 1)
{
}
}
public static void AssertRangeValue(AutomationElement element, double expected)
{
RangeValuePattern currentPattern = AutomationPatternHelper.GetRangeValuePattern(element);
double num = currentPattern.Current.Value;
if (expected != num)
{
throw new Exception(string.Format("RangeValue is not as expected. Expected: {0}, Actual: {1}. ({2})", expected, num, element.ToString()));
}
}
public void SetValue(double value, bool log)
{
if (log)
{
procedureLogger.Action(string.Format("Set {0} to {1}.", value, this.NameAndType));
}
RangeValuePattern rvp = (RangeValuePattern)element.GetCurrentPattern(RangeValuePattern.Pattern);
rvp.SetValue(value);
}
public static bool TryGetRangeValuePattern(this AutomationElement element, out RangeValuePattern result)
{
if (element.TryGetCurrentPattern(System.Windows.Automation.RangeValuePattern.Pattern, out var pattern))
{
result = (RangeValuePattern)pattern;
return(true);
}
result = null;
return(false);
}
///--------------------------------------------------------------------
/// <summary>
/// Handle RangeValue events of interest.
/// </summary>
/// <param name="src">Object that raised the event.</param>
/// <param name="e">Event arguments.</param>
///--------------------------------------------------------------------
private void OnRangeValueChange(object src, AutomationEventArgs e)
{
AutomationElement rangevalueElement = src as AutomationElement;
AutomationEvent rangevalueEvent = e.EventId;
RangeValuePattern rangevaluePattern =
rangevalueElement.GetCurrentPattern(RangeValuePattern.Pattern)
as RangeValuePattern;
string scriptAction =
"scriptFunctions.SetRangeValue(\"" +
EscapeChars(rangevalueElement.Cached.AutomationId) +
"\", " + rangevaluePattern.Current.Value + ");";
if (rangevalueElement.Current.HasKeyboardFocus)
{
Feedback("RangeValue event.");
Feedback(rangevalueElement.Cached.Name);
StoreElement(rangevalueElement, rangevalueEvent, scriptAction);
}
}
// </Snippet100>
// <Snippet101>
///--------------------------------------------------------------------
/// <summary>
/// Obtains a RangeValuePattern control pattern from an
/// automation element.
/// </summary>
/// <param name="targetControl">
/// The automation element of interest.
/// </param>
/// <returns>
/// A RangeValuePattern object.
/// </returns>
///--------------------------------------------------------------------
private RangeValuePattern GetRangeValuePattern(
AutomationElement targetControl)
{
RangeValuePattern rangeValuePattern = null;
try
{
rangeValuePattern =
targetControl.GetCurrentPattern(
RangeValuePattern.Pattern)
as RangeValuePattern;
}
// Object doesn't support the
// RangeValuePattern control pattern
catch (InvalidOperationException)
{
return(null);
}
return(rangeValuePattern);
}
public new void Set(string value)
{
this.PrepareForReplay();
try
{
RangeValuePattern v = (RangeValuePattern)this._condition.AutomationElement.GetCurrentPattern(RangeValuePattern.Pattern);
v.SetValue(Convert.ToDouble(value));
}
catch
{
}
try
{
ValuePattern v = (ValuePattern)this._condition.AutomationElement.GetCurrentPattern(ValuePattern.Pattern);
v.SetValue(value);
}
catch
{
ControlSearcher.ThrowError(ErrorType.CannotPerformThisOperation);
}
}
///--------------------------------------------------------------------
/// <summary>
/// RangeValue support function.
/// </summary>
/// <param name="automationID">
/// The AutomationID of the target element.
/// </param>
/// <param name="rangevalue">
/// The new range value.
/// </param>
///--------------------------------------------------------------------
internal void SetRangeValue(string automationID, int rangevalue)
{
AutomationElement element;
element = FindElement(automationID);
if (element == null)
{
Feedback(automationID.ToString() + " could not be found.");
return;
}
if ((bool)element.GetCurrentPropertyValue(AutomationElement.IsEnabledProperty) == false)
{
Feedback("Element not enabled.");
return;
}
RangeValuePattern rangevaluePattern =
element.GetCurrentPattern(RangeValuePattern.Pattern)
as RangeValuePattern;
rangevaluePattern.SetValue(rangevalue);
Feedback(automationID.ToString() + " value changed.");
}
public void RangeValuePatternTest()
{
using (AppHost host = new AppHost("rundll32.exe", "shell32.dll,Control_RunDLL main.cpl ,2"))
{
// Find a well-known slider
AutomationElement slider = host.Element.FindFirst(TreeScope.Subtree,
new PropertyCondition(AutomationElement.AutomationIdProperty, "101"));
Assert.IsNotNull(slider);
RangeValuePattern range = (RangeValuePattern)slider.GetCurrentPattern(RangeValuePattern.Pattern);
double originalValue = range.Current.Value;
try
{
Assert.IsTrue(range.Current.SmallChange >= 0);
Assert.IsTrue(range.Current.LargeChange >= 0);
Assert.IsTrue(originalValue >= range.Current.Minimum);
Assert.IsTrue(originalValue <= range.Current.Maximum);
Assert.IsFalse(range.Current.IsReadOnly);
range.SetValue(range.Current.Minimum);
System.Threading.Thread.Sleep(100 /* ms */);
Assert.AreEqual(range.Current.Value, range.Current.Minimum);
range.SetValue(range.Current.Maximum);
System.Threading.Thread.Sleep(100 /* ms */);
Assert.AreEqual(range.Current.Value, range.Current.Maximum);
double midpoint = (range.Current.Maximum + range.Current.Minimum) / 2;
range.SetValue(midpoint);
System.Threading.Thread.Sleep(100 /* ms */);
Assert.AreEqual(range.Current.Value, midpoint);
}
finally
{
range.SetValue(originalValue);
}
}
}
// </Snippet102>
// <Snippet103>
///--------------------------------------------------------------------
/// <summary>
/// Sets the range value of the control of interest.
/// </summary>
/// <param name="targetControl">
/// The automation element of interest.
/// </param>
/// <param name="rangeValue">
/// The value (either relative or absolute) to set the control to.
/// </param>
/// <param name="rangeDirection">
/// The value used to specify the direction of adjustment.
/// </param>
///--------------------------------------------------------------------
private void SetRangeValue(
AutomationElement targetControl,
double rangeValue,
double rangeDirection)
{
if (targetControl == null || rangeValue == 0 || rangeDirection == 0)
{
throw new ArgumentException("Argument cannot be null or zero.");
}
RangeValuePattern rangeValuePattern =
GetRangeValuePattern(targetControl);
if (rangeValuePattern.Current.IsReadOnly)
{
throw new InvalidOperationException("Control is read-only.");
}
rangeValue = rangeValue * Math.Sign(rangeDirection);
try
{
if ((rangeValue <= rangeValuePattern.Current.Maximum) ||
(rangeValue >= rangeValuePattern.Current.Minimum))
{
rangeValuePattern.SetValue(rangeValue);
}
}
catch (ArgumentOutOfRangeException)
{
// TO DO: Error handling.
}
catch (ArgumentException)
{
// TO DO: Error handling.
}
}
// </Snippet101>
// <Snippet102>
///--------------------------------------------------------------------
/// <summary>
/// Gets the current property values from target.
/// </summary>
/// <param name="rangeValuePattern">
/// A RangeValuePattern control pattern obtained from
/// an automation element representing a target control.
/// </param>
/// <param name="automationProperty">
/// The automation property of interest.
/// </param>
///--------------------------------------------------------------------
private object GetRangeValueProperty(
RangeValuePattern rangeValuePattern,
AutomationProperty automationProperty)
{
if (rangeValuePattern == null || automationProperty == null)
{
throw new ArgumentException("Argument cannot be null.");
}
if (automationProperty.Id ==
RangeValuePattern.MinimumProperty.Id)
{
return(rangeValuePattern.Current.Minimum);
}
if (automationProperty.Id ==
RangeValuePattern.MaximumProperty.Id)
{
return(rangeValuePattern.Current.Maximum);
}
if (automationProperty.Id ==
RangeValuePattern.SmallChangeProperty.Id)
{
return(rangeValuePattern.Current.SmallChange);
}
if (automationProperty.Id ==
RangeValuePattern.LargeChangeProperty.Id)
{
return(rangeValuePattern.Current.LargeChange);
}
if (automationProperty.Id ==
RangeValuePattern.ValueProperty.Id)
{
return(rangeValuePattern.Current.Value);
}
return(null);
}
public void PatternController(AutomationPattern pat, AutomationElement selectedItem, ListView listView2)
{
if (pat == ScrollPattern.Pattern)
{
ScrollPattern scrollPattern = selectedItem.GetCurrentPattern(ScrollPattern.Pattern) as ScrollPattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "Scroll - not implemented";
lvi.Tag = new PatternInfo(1, 1, selectedItem, scrollPattern);
listView2.Items.Add(lvi);
}
else if (pat == DockPattern.Pattern)
{
DockPattern dockPattern = selectedItem.GetCurrentPattern(DockPattern.Pattern) as DockPattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "SetDockPosition - not implemented";
lvi.Tag = new PatternInfo(2, 1, selectedItem, dockPattern);
listView2.Items.Add(lvi);
}
else if (pat == ExpandCollapsePattern.Pattern)
{
ExpandCollapsePattern expandCollapsePattern = selectedItem.GetCurrentPattern(ExpandCollapsePattern.Pattern) as ExpandCollapsePattern;
ListViewItem lvi1 = new ListViewItem();
lvi1.Content = "Expand";
lvi1.Tag = new PatternInfo(3, 1, selectedItem, expandCollapsePattern);
listView2.Items.Add(lvi1);
ListViewItem lvi2 = new ListViewItem();
lvi2.Content = "Collapse";
lvi2.Tag = new PatternInfo(3, 2, selectedItem, expandCollapsePattern);
listView2.Items.Add(lvi2);
}
else if (pat == GridPattern.Pattern)
{
GridPattern gridPattern = selectedItem.GetCurrentPattern(GridPattern.Pattern) as GridPattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "GetItem - not implemented";
lvi.Tag = new PatternInfo(4, 1, selectedItem, gridPattern);
listView2.Items.Add(lvi);
}
else if (pat == GridItemPattern.Pattern)
{
}
else if (pat == InvokePattern.Pattern)
{
InvokePattern invokePattern = selectedItem.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "Invoke";
lvi.Tag = new PatternInfo(6, 1, selectedItem, invokePattern);
listView2.Items.Add(lvi);
}
else if (pat == ItemContainerPattern.Pattern)
{
}
else if (pat == MultipleViewPattern.Pattern)
{
}
else if (pat == RangeValuePattern.Pattern)
{
RangeValuePattern rangeValuePattern = selectedItem.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "SetValue - not implemented";
lvi.Tag = new PatternInfo(9, 1, selectedItem, rangeValuePattern);
listView2.Items.Add(lvi);
}
else if (pat == ScrollItemPattern.Pattern)
{
}
else if (pat == SelectionItemPattern.Pattern)
{
}
else if (pat == SelectionPattern.Pattern)
{
}
else if (pat == SynchronizedInputPattern.Pattern)
{
}
else if (pat == TextPattern.Pattern)
{
}
else if (pat == TogglePattern.Pattern)
{
TogglePattern togglePattern = selectedItem.GetCurrentPattern(TogglePattern.Pattern) as TogglePattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "Toggle";
lvi.Tag = new PatternInfo(15, 1, selectedItem, togglePattern);
listView2.Items.Add(lvi);
}
else if (pat == TransformPattern.Pattern)
{
TransformPattern transformPattern = selectedItem.GetCurrentPattern(TransformPattern.Pattern) as TransformPattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "Move - not implemented";
lvi.Tag = new PatternInfo(16, 1, selectedItem, transformPattern);
listView2.Items.Add(lvi);
ListViewItem lvi2 = new ListViewItem();
lvi2.Content = "Resize - not implemented";
lvi2.Tag = new PatternInfo(16, 2, selectedItem, transformPattern);
listView2.Items.Add(lvi2);
ListViewItem lvi3 = new ListViewItem();
lvi3.Content = "Rotate - not implemented";
lvi3.Tag = new PatternInfo(16, 3, selectedItem, transformPattern);
listView2.Items.Add(lvi3);
}
else if (pat == ValuePattern.Pattern)
{
ValuePattern valuePattern = selectedItem.GetCurrentPattern(ValuePattern.Pattern) as ValuePattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "setValue";
lvi.Tag = new PatternInfo(17, 1, selectedItem, valuePattern);
listView2.Items.Add(lvi);
}
else if (pat == VirtualizedItemPattern.Pattern)
{
}
else if (pat == WindowPattern.Pattern)
{
WindowPattern windowPattern = selectedItem.GetCurrentPattern(WindowPattern.Pattern) as WindowPattern;
ListViewItem lvi = new ListViewItem();
lvi.Content = "SetWindowVisualState - not implemented";
lvi.Tag = new PatternInfo(19, 1, selectedItem, windowPattern);
listView2.Items.Add(lvi);
}
else
{
listView2.Items.Add("else");
}
}
/// <summary>
/// Gets the small-change value, unique to the UI Automation element, which is added to or subtracted from the elements Value property.
/// </summary>
/// <param name="control">The UI Automation element.</param>
/// <returns>
/// The small-change value
/// </returns>
internal static double GetSmallChange(AutomationElement control)
{
RangeValuePattern pattern = (RangeValuePattern)CommonUIAPatternHelpers.CheckPatternSupport(RangeValuePattern.Pattern, control);
return(pattern.Current.SmallChange);
}
/// <summary></summary>
public RangeValuePatternPropertyObject(RangeValuePattern pattern)
{
this._pattern = pattern;
}
public ProgressBar(AutomationElement button)
{
this.progressBar = button;
this.RangeValue = progressBar.GetCurrentPattern(RangeValuePattern.Pattern) as RangeValuePattern;
}
/// -------------------------------------------------------------------
/// <summary></summary>
/// -------------------------------------------------------------------
protected RangeValuePatternWrapper(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)
{
m_pattern = (RangeValuePattern)GetPattern(m_le, m_useCurrent, RangeValuePattern.Pattern);
}
