/// <summary>
/// Starts searching for windows by its title.
/// </summary>
/// <param name="title">The window title to search for.</param>
/// <param name="comparison">The comparison kind how the window title will be compared.</param>
/// <returns>A combinable Use to be able to append additional conditions.</returns>
public new CombinableUse Title(string title, CompareKind comparison)
{
_conditions.Add(window => StringExtensions.Match(window.Title, title, comparison));
_conditionDescriptions.Add(string.Format("StringExtensions.Match(window.Title, \"{0}\", CompareKind.{1})", title, comparison));
return(this);
}
public static bool Match(string sourceString, string searchPattern, CompareKind compareKind)
{
if (sourceString == null || searchPattern == null)
{
return(false);
}
switch (compareKind)
{
case CompareKind.Contains:
return(sourceString.Contains(searchPattern));
case CompareKind.ContainsIgnoreCase:
return(sourceString.ToLower().Contains(searchPattern.ToLower()));
case CompareKind.EndsWith:
return(sourceString.EndsWith(searchPattern));
case CompareKind.EndsWithIgnoreCase:
return(sourceString.ToLower().EndsWith(searchPattern.ToLower()));
case CompareKind.Exact:
return(sourceString.Equals(searchPattern));
case CompareKind.ExactIgnoreCase:
return(sourceString.ToLower().Equals(searchPattern.ToLower()));
case CompareKind.StartsWith:
return(sourceString.StartsWith(searchPattern));
case CompareKind.StartsWithIgnoreCase:
return(sourceString.ToLower().StartsWith(searchPattern.ToLower()));
}
return(false);
}
public CompareIntriniscAttribute(
CompareKind intrinsicKind,
CompareFlags intrinsicFlags)
{
IntrinsicKind = intrinsicKind;
IntrinsicFlags = intrinsicFlags;
}
public static String Sign(CompareKind pCompareKind)
{
switch (pCompareKind)
{
case CompareKind.None: return(" = ");
case CompareKind.Equal: return(" = ");;
case CompareKind.IsNULL: return(" IS NULL ");
case CompareKind.Major: return(" > ");
case CompareKind.Minor: return(" < ");
case CompareKind.IsNotNULL: return("IS NOT NULL");
case CompareKind.NotEqual: return(" <> ");
case CompareKind.Like: return(" LIKE ");
case CompareKind.In: return(" IN ");
case CompareKind.MajorAndEqual: return(" >= ");
case CompareKind.MinorAndEqual: return(" <= ");
default: return(" = ");
}
}
/// <summary>
/// Starts the search for the UI element by the name.
/// </summary>
/// <param name="className">The class name to search for.</param>
/// <param name="comparison">The comparison kind how the class name will be compared.</param>
/// <returns>A combinable By to be able to append additional conditions.</returns>
/// <exception cref="System.ArgumentException">className is null, empty or just whitespaces.</exception>
/// <remarks>If CompareKind is not set to <see cref="DW.CodedUI.CompareKind.Exact" /> or <see cref="DW.CodedUI.CompareKind.ExactIgnoreCase" />, the whole search causes a memory leak in the target application.<br />
/// The reason of this is that for custom conditions the TreeWalker needs to be used and this has the known issue.</remarks>
public new CombinableBy ClassName(string className, CompareKind comparison)
{
if (string.IsNullOrWhiteSpace(className))
{
throw new ArgumentException("className is null, empty or just whitespaces.");
}
_conditions.Add(element =>
{
if (element == null)
{
return(false);
}
return(StringExtensions.Match(element.Properties.ClassName, className, comparison));
});
_conditionDescriptions.Add(string.Format("StringExtensions.Match(element.Properties.ClassName, \"{0}\", CompareKind.{1})", className, comparison));
if (CanBeRaw(comparison))
{
var propertyConditionFlags = ToPropertyConditionFlag(comparison);
_rawConditions.Add(new PropertyCondition(AutomationElement.ClassNameProperty, className, propertyConditionFlags));
_rawConditionDescriptions.Add(string.Format("new PropertyCondition(AutomationElement.ClassNameProperty, \"{0}\", {1}", className, propertyConditionFlags));
}
else
{
_rawConditions.Clear();
}
return(this);
}
/// <summary>
/// Resolves a compare operation.
/// </summary>
/// <param name="kind">The compare kind.</param>
/// <param name="flags">The compare flags.</param>
/// <param name="type">The type to compare.</param>
/// <returns>The resolved compare operation.</returns>
public static string GetCompareOperation(
CompareKind kind,
CompareFlags flags,
ArithmeticBasicValueType type)
{
var unorderedFloatComparison = type.IsFloat() &&
flags.HasFlag(CompareFlags.UnsignedOrUnordered);
if (unorderedFloatComparison)
{
if (CompareUnorderedFloatOperations.TryGetValue(
(kind, type),
out string operation))
{
return(operation);
}
}
else
{
if (CompareOperations.TryGetValue((kind, type), out string operation))
{
return(operation);
}
}
throw new NotSupportedIntrinsicException(kind.ToString());
}
public ErrorRecordComparer(CompareKind kind)
{
//The compare kind determines which field to compare Error Records with.
m_Kind = kind;
}
/// <summary>
/// Inverts the given compare kind.
/// </summary>
/// <param name="kind">The compare kind to invert.</param>
/// <returns>The inverted compare kind.</returns>
public static CompareKind Invert(CompareKind kind)
{
switch (kind)
{
case CompareKind.Equal:
return(CompareKind.NotEqual);
case CompareKind.NotEqual:
return(CompareKind.Equal);
case CompareKind.LessThan:
return(CompareKind.GreaterEqual);
case CompareKind.LessEqual:
return(CompareKind.GreaterThan);
case CompareKind.GreaterThan:
return(CompareKind.LessEqual);
case CompareKind.GreaterEqual:
return(CompareKind.LessThan);
default:
throw new ArgumentOutOfRangeException(nameof(kind));
}
}
/// <summary>
/// Realizes a compare instruction of the given type.
/// </summary>
/// <param name="compareKind">The comparison kind.</param>
/// <param name="instructionFlags">The instruction flags.</param>
private void MakeCompare(
CompareKind compareKind,
ILInstructionFlags instructionFlags)
{
var value = CreateCompare(compareKind, instructionFlags);
Block.Push(value);
}
/// <summary>
/// Inverts the given compare kind if it is not commutative.
/// </summary>
/// <param name="kind">The compare kind to invert.</param>
/// <returns>The inverted compare kind.</returns>
public static CompareKind InvertIfNonCommutative(CompareKind kind)
{
if (IsCommutative(kind))
{
return(kind);
}
return(Invert(kind));
}
/// <summary>
/// Resolves a compare operation.
/// </summary>
/// <param name="kind">The compare kind.</param>
/// <param name="type">The type to compare.</param>
/// <returns>The resolved compare operation.</returns>
public static string GetCompareOperation(CompareKind kind, ArithmeticBasicValueType type)
{
if (CompareOperations.TryGetValue((kind, type), out string operation))
{
return(operation);
}
throw new NotSupportedIntrinsicException(kind.ToString());
}
public void GetBytes_CompareInstruction(CompareKind compareKind)
{
var instruction = new CompareInstruction(compareKind);
var expectedBytes = InstructionByteBuilder.Create()
.Opcode(Opcode.Compare, compareKind)
.AsSpan();
Assert.True(expectedBytes.SequenceEqual(instruction.GetBytes()));
}
public void Decode_CompareInstruction_FromBytesArray(CompareKind compareKind)
{
var bytes = InstructionByteBuilder.Create()
.Opcode(Opcode.Compare, compareKind)
.ToArray();
var compareInstruction = AssertBytesDecodedAs <CompareInstruction>(bytes);
Assert.Equal(compareKind, compareInstruction.CompareKind);
}
/// <summary>
/// Realizes a compare instruction of the given type.
/// </summary>
/// <param name="block">The current basic block.</param>
/// <param name="builder">The current builder.</param>
/// <param name="compareKind">The comparison kind.</param>
/// <param name="instructionFlags">The instruction flags.</param>
private static void MakeCompare(
Block block,
IRBuilder builder,
CompareKind compareKind,
ILInstructionFlags instructionFlags)
{
var value = CreateCompare(block, builder, compareKind, instructionFlags);
block.Push(value);
}
private PropertyConditionFlags ToPropertyConditionFlag(CompareKind comparison)
{
switch (comparison)
{
case CompareKind.ExactIgnoreCase:
return(PropertyConditionFlags.IgnoreCase);
default:
return(PropertyConditionFlags.None);
}
}
/// <summary>
/// Creates a compare operation.
/// </summary>
/// <param name="location">The current location.</param>
/// <param name="left">The left operand.</param>
/// <param name="right">The right operand.</param>
/// <param name="kind">The operation kind.</param>
/// <returns>A node that represents the compare operation.</returns>
public ValueReference CreateCompare(
Location location,
Value left,
Value right,
CompareKind kind) =>
CreateCompare(
location,
left,
right,
kind,
CompareFlags.None);
/// <summary>
/// Creates a compare instruction of the given type.
/// </summary>
/// <param name="block">The current basic block.</param>
/// <param name="builder">The current builder.</param>
/// <param name="compareKind">The comparison kind.</param>
/// <param name="flags">The comparison flags.</param>
private static Value CreateCompare(
Block block,
IRBuilder builder,
CompareKind compareKind,
CompareFlags flags)
{
var right = block.PopCompareValue(ConvertFlags.None);
var left = block.PopCompareValue(ConvertFlags.None);
return(CreateCompare(builder, left, right, compareKind, flags));
}
/// <summary>
/// Creates a compare instruction of the given type.
/// </summary>
/// <param name="compareKind">The comparison kind.</param>
/// <param name="flags">The comparison flags.</param>
private Value CreateCompare(CompareKind compareKind, CompareFlags flags)
{
var right = Block.PopCompareValue(Location, ConvertFlags.None);
var left = Block.PopCompareValue(Location, ConvertFlags.None);
return(CreateCompare(
left,
right,
compareKind,
flags));
}
/// <summary>
/// Adjusts the given compare kind and the associated flags for swapping the
/// operands of a compare operation.
/// </summary>
/// <param name="kind">The compare kind to invert.</param>
/// <param name="leftType">The basic value type of the left operand..</param>
/// <param name="rightType">The basic value type of the right operand.</param>
/// <param name="flags">The compare flags that might be adjusted.</param>
/// <returns>The adjusted compare kind.</returns>
public static CompareKind SwapOperands(
CompareKind kind,
BasicValueType leftType,
BasicValueType rightType,
ref CompareFlags flags) =>
UpdateFlags(
kind,
Swapped[(int)kind],
leftType,
rightType,
ref flags);
/// <summary>
/// Inverts the given compare kind.
/// </summary>
/// <param name="kind">The compare kind to invert.</param>
/// <param name="leftType">The basic value type of the left operand..</param>
/// <param name="rightType">The basic value type of the right operand.</param>
/// <param name="flags">The compare flags that might be adjusted.</param>
/// <returns>The inverted compare kind.</returns>
public static CompareKind Invert(
CompareKind kind,
BasicValueType leftType,
BasicValueType rightType,
ref CompareFlags flags) =>
UpdateFlags(
kind,
Inverted[(int)kind],
leftType,
rightType,
ref flags);
/// <summary>
/// Realizes a conditional branch instruction.
/// </summary>
/// <param name="block">The current basic block.</param>
/// <param name="builder">The current builder.</param>
/// <param name="compareKind">The comparison type of the condition.</param>
/// <param name="instructionFlags">The instruction flags.</param>
private static void MakeBranch(
Block block,
IRBuilder builder,
CompareKind compareKind,
ILInstructionFlags instructionFlags)
{
var targets = block.GetBuilderTerminator(2);
var condition = CreateCompare(block, builder, compareKind, instructionFlags);
builder.CreateConditionalBranch(condition, targets[0], targets[1]);
}
private bool CanBeRaw(CompareKind comparison)
{
switch (comparison)
{
case CompareKind.Exact:
case CompareKind.ExactIgnoreCase:
return(true);
default:
return(false);
}
}
/// <summary>
/// Creates a compare instruction of the given type.
/// </summary>
/// <param name="compareKind">The comparison kind.</param>
/// <param name="instructionFlags">The instruction flags.</param>
private Value CreateCompare(
CompareKind compareKind,
ILInstructionFlags instructionFlags)
{
var compareFlags = CompareFlags.None;
if (instructionFlags.HasFlags(ILInstructionFlags.Unsigned))
{
compareFlags |= CompareFlags.UnsignedOrUnordered;
}
return(CreateCompare(compareKind, compareFlags));
}
/// <summary>
/// Make an intrinsic branch.
/// </summary>
/// <param name="block">The current basic block.</param>
/// <param name="builder">The current builder.</param>
/// <param name="kind">The current compare kind.</param>
private static void MakeIntrinsicBranch(
Block block,
IRBuilder builder,
CompareKind kind)
{
var targets = block.GetBuilderTerminator(2);
var comparisonValue = block.PopCompareValue(ConvertFlags.None);
var rightValue = builder.CreatePrimitiveValue(comparisonValue.BasicValueType, 0);
var condition = CreateCompare(builder, comparisonValue, rightValue, kind, CompareFlags.None);
builder.CreateConditionalBranch(condition, targets[0], targets[1]);
}
/// <summary>
/// Creates a compare instruction of the given type.
/// </summary>
/// <param name="block">The current basic block.</param>
/// <param name="builder">The current builder.</param>
/// <param name="compareKind">The comparison kind.</param>
/// <param name="instructionFlags">The instruction flags.</param>
private static Value CreateCompare(
Block block,
IRBuilder builder,
CompareKind compareKind,
ILInstructionFlags instructionFlags)
{
var compareFlags = CompareFlags.None;
if (instructionFlags.HasFlags(ILInstructionFlags.Unsigned))
{
compareFlags |= CompareFlags.UnsignedOrUnordered;
}
return(CreateCompare(block, builder, compareKind, compareFlags));
}
/// <summary>
/// Constructs a new compare value.
/// </summary>
/// <param name="context">The parent IR context.</param>
/// <param name="basicBlock">The parent basic block.</param>
/// <param name="left">The left operand.</param>
/// <param name="right">The right operand.</param>
/// <param name="kind">The operation kind.</param>
/// <param name="flags">The operation flags.</param>
internal CompareValue(
IRContext context,
BasicBlock basicBlock,
ValueReference left,
ValueReference right,
CompareKind kind,
CompareFlags flags)
: base(ValueKind.Compare, basicBlock, ComputeType(context))
{
Kind = kind;
Flags = flags;
Seal(ImmutableArray.Create(left, right));
}
/// <summary>
/// Realizes a conditional branch instruction.
/// </summary>
/// <param name="compareKind">The comparison type of the condition.</param>
/// <param name="instructionFlags">The instruction flags.</param>
private void MakeBranch(
CompareKind compareKind,
ILInstructionFlags instructionFlags)
{
var targets = Block.GetBuilderTerminator(2);
var condition = CreateCompare(compareKind, instructionFlags);
Builder.CreateIfBranch(
Location,
condition,
targets[0],
targets[1]);
}
/// <summary>
/// Create a new parameter instance
/// </summary>
/// <param name="pParameterName">Parameter's name</param>
/// <param name="pCompareKind">Compare operation</param>
/// <param name="pValue">Parameter's value</param>
/// <returns>Parameter</returns>
protected RecordParameter CreateParameter(String pParameterName, CompareKind pCompareKind, object pValue)
{
if (ProviderFactory == null)
{
throw new RecordProviderFactoryNullException("Provider Factory is null");
}
DbParameter parameter = (DbParameter)ProviderFactory.CreateParameter();
parameter.ParameterName = pParameterName;
parameter.Value = pValue != null ? pValue : String.Empty;
RecordParameter rparameter = new RecordParameter(parameter, pCompareKind);
return(rparameter);
}
/// <summary>
/// Updates the compare flags according to the potentially updated operation
/// kind.
/// </summary>
/// <param name="kind">The current operation kind.</param>
/// <param name="newKind">The new (potentially updated) operation kind.</param>
/// <param name="leftType">The left basic value type.</param>
/// <param name="rightType">The right basic value type.</param>
/// <param name="flags">The current flags to be updated.</param>
/// <returns>The value of <paramref name="newKind"/>.</returns>
private static CompareKind UpdateFlags(
CompareKind kind,
CompareKind newKind,
BasicValueType leftType,
BasicValueType rightType,
ref CompareFlags flags)
{
// If the comparison was swapped or inverted, and we are comparing floats,
// toggle between ordered/unordered float comparisons
if (kind != newKind && leftType.IsFloat() && rightType.IsFloat())
{
flags ^= CompareFlags.UnsignedOrUnordered;
}
return(newKind);
}
/// <summary>
/// Creates a compare instruction of the given type.
/// </summary>
/// <param name="left">The left operand.</param>
/// <param name="right">The right operand.</param>
/// <param name="builder">The current builder.</param>
/// <param name="compareKind">The comparison kind.</param>
/// <param name="flags">The comparison flags.</param>
private static Value CreateCompare(
IRBuilder builder,
Value left,
Value right,
CompareKind compareKind,
CompareFlags flags)
{
var convertFlags = ConvertFlags.None;
if ((flags & CompareFlags.UnsignedOrUnordered) == CompareFlags.UnsignedOrUnordered)
{
convertFlags = ConvertFlags.SourceUnsigned;
}
right = CreateConversion(builder, right, left.Type, convertFlags);
left = CreateConversion(builder, left, right.Type, convertFlags);
Debug.Assert(left.BasicValueType == right.BasicValueType);
return(builder.CreateCompare(left, right, compareKind, flags));
}
