public void MergeWith(ITermSettings otherTermSettings)
{
otherTermSettings.CheckNotNull("otherTermSettings");
if (otherTermSettings.Case != TermCase.Inherit)
Case = otherTermSettings.Case;
if (otherTermSettings.Match != TermMatch.Inherit)
Match = otherTermSettings.Match;
if (otherTermSettings.Format != null)
Format = otherTermSettings.Format;
}
public static TOwner ContainHavingContent <TControl, TOwner>(this IDataVerificationProvider <IEnumerable <TControl>, TOwner> should, TermMatch match, params string[] expected)
where TControl : Control <TOwner>
where TOwner : PageObject <TOwner>
{
return(should.ContainHavingContent(match, expected.AsEnumerable()));
}
protected VerifyHeadingTriggerAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
public TermFindSettingsAttribute(FindTermBy by, TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
: this(by.ResolveFindAttributeType(), match, termCase)
{
}
public FindByTitleAttribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public TermAttribute(TermMatch match, params string[] values)
: this(values, match)
{
}
public static TOwner MatchAny <TOwner>(this IDataVerificationProvider <string, TOwner> should, TermMatch match, params string[] expected)
where TOwner : PageObject <TOwner>
{
expected.CheckNotNullOrEmpty(nameof(expected));
var predicate = match.GetPredicate();
string message = new StringBuilder().
Append($"{match.GetShouldText()} ").
AppendIf(expected.Length > 1, "any of: ").
AppendJoined(", ", Enumerable.Range(0, expected.Length).Select(x => $"{{{x}}}")).
ToString();
return(should.Satisfy(actual => actual != null && expected.Any(x => predicate(actual, x)), message, expected));
}
public VerifyH2Attribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public FindItemByRelativeElementContentAttribute(string relativeElementXPath, TermMatch match, TermCase termCase)
: base(match, termCase)
{
RelativeElementXPath = relativeElementXPath;
}
public SelectByTextAttribute(TermMatch match, TermCase termCase)
: base(match, termCase)
{
}
public FindByContentOrValueAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
public SelectByTextAttribute(TermMatch match)
: base(match)
{
}
public FindByContentOrValueAttribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public FindByContentOrValueAttribute(TermMatch match, TermCase termCase)
: base(match, termCase)
{
}
protected TermFindAttribute(string[] values = null, TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
{
Values = values;
Match = match;
Case = termCase;
}
protected TermFindAttribute(TermMatch match, TermCase termCase)
: this()
{
Match = match;
Case = termCase;
}
protected TermVerificationTriggerAttribute(TermMatch match, params string[] values)
: this(values)
{
Match = match;
}
protected TermFindAttribute(TermMatch match, params string[] values)
: this(values)
{
Match = match;
}
public static TOwner ContainHavingContent <TControl, TOwner>(this IDataVerificationProvider <IEnumerable <TControl>, TOwner> should, TermMatch match, params string[] expected)
where TControl : Control <TOwner>
where TOwner : PageObject <TOwner>
{
expected.CheckNotNullOrEmpty(nameof(expected));
return(should.Satisfy(
actual =>
{
if (actual == null)
{
return false;
}
var actualValues = actual.Select(x => x.Content.Value).ToArray();
return should.IsNegation
? expected.Any(expectedValue => actualValues.Any(actualValue => match.IsMatch(actualValue, expectedValue)))
: expected.All(expectedValue => actualValues.Any(actualValue => match.IsMatch(actualValue, expectedValue)));
},
$"contain having content that {match.ToString(TermCase.MidSentence)} {CollectionToString(expected)}"));
}
public FindItemByPrecedingSiblingContentAttribute(TermMatch match, TermCase termCase)
: base(PrecedingSiblingElementXPath, match, termCase)
{
}
public FindByChildContentAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
public WindowTitleAttribute(TermMatch match, TermCase termCase = DefaultCase)
: this(null, match, termCase)
{
}
public FindByContentAttribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public WindowTitleAttribute(TermMatch match, params string[] values)
: this(values, match)
{
}
public SelectByValueAttribute(TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
private WindowTitleAttribute(string[] values = null, TermMatch match = DefaultMatch, TermCase termCase = DefaultCase)
{
Values = values;
Match = match;
Case = termCase;
}
public FindItemByValueAttribute(TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
public FindItemByLabelAttribute(TermMatch match)
: base(match)
{
}
public FindByAttributeAttribute(string attributeName, TermMatch match, params string[] values)
: this(attributeName, values, match)
{
}
public FindItemByLabelAttribute(TermMatch match, TermCase termCase)
: base(match, termCase)
{
}
protected TermFindAttribute(TermMatch match, params string[] values)
: this(values, match)
{
}
public static bool IsMatch(this TermMatch match, string text, params string[] terms)
{
var predicate = match.GetPredicate();
return(terms.Any(term => predicate(text, term)));
}
protected TermVerificationTriggerAttribute(TermMatch match, TermCase termCase)
: this()
{
Match = match;
Case = termCase;
}
public FindByDescriptionTermAttribute(TermMatch match, TermCase termCase)
: base(match, termCase)
{
}
public VerifyH2Attribute(TermMatch match, TermCase termCase)
: base(match, termCase)
{
}
public FindByDescriptionTermAttribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public static TOwner Contain <TOwner>(this IDataVerificationProvider <IEnumerable <IDataProvider <string, TOwner> >, TOwner> should, TermMatch match, params string[] expected)
where TOwner : PageObject <TOwner>
{
expected.CheckNotNullOrEmpty(nameof(expected));
return(should.Satisfy(
actual => actual != null && should.IsNegation
? expected.Any(expectedValue => actual.Any(actualValue => match.IsMatch(actualValue, expectedValue)))
: expected.All(expectedValue => actual.Any(actualValue => match.IsMatch(actualValue, expectedValue))),
$"contain having value that {match.ToString(TermCase.MidSentence)} {CollectionToString(expected)}"));
}
public bool Excludes(TermMatch match)
{
return(match.Term == _exclusion.Term &&
MatchFinder.RangeContains(_line, _column, _line, _column + _exclusion.Text.Length - 1, match.Line, match.Column) &&
MatchFinder.RangeContains(_line, _column, _line, _column + _exclusion.Text.Length - 1, match.Line, match.Column + match.Term.Term.Text.Length - 1));
}
public VerifyTitleSettingsAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
void RemoveAllMatchesInRangeExceptOne(int lineStart, int columnStart, int lineEnd, int columnEnd, TermMatch matchToSave)
{
foreach (TermMatch match in PartiallyMatchedTerms)
{
if (match != matchToSave && RangesOverlap(lineStart, columnStart, lineEnd, columnEnd, match.Line, match.Column, match.Line, match.Column + match.Term.Term.Text.Length - 1))
{
match.MarkForDiscard();
}
}
}
protected TermFindItemAttribute(TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
{
Match = match;
Case = termCase;
}
protected TermFindItemAttribute(TermMatch match)
{
Match = match;
}
public TermAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: this(null, match, termCase)
{
}
protected TermFindItemAttribute(TermMatch match, TermCase termCase)
{
Match = match;
Case = termCase;
}
private TermAttribute(string[] values = null, TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
{
Values = values;
Match = match;
Case = termCase;
}
public SelectsOptionByLabelAttributeAttribute(TermMatch match)
: base(LabelAttributeName, match)
{
}
public FindByTitleAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
public SelectsOptionByLabelAttributeAttribute(TermMatch match, TermCase termCase)
: base(LabelAttributeName, match, termCase)
{
}
// Collapse together subsequent matches for same value or value has same range as no preference
internal static IEnumerable<TermMatch> Coalesce(IEnumerable<TermMatch> matches, string input)
{
var sorted = (from match in matches
orderby match.Start ascending
, match.End ascending
, match.Value == null ascending
select match).ToList();
while (sorted.Count() > 0)
{
var current = sorted.First();
sorted.Remove(current);
bool emit = true;
foreach (var next in sorted.ToList())
{
if (next.Covers(current))
{
// Current is completely covered by a subsequent match
emit = false;
break;
}
else if (current.End < next.Start)
{
var gap = next.Start - current.End;
if (gap > 1 && !Language.NonWord(input.Substring(current.End, gap)))
{
// Unmatched word means we can't merge any more
emit = true;
break;
}
else if (current.Value == next.Value || IsSpecial(current.Value) || IsSpecial(next.Value))
{
// Compatible, extend current match
current = new TermMatch(current.Start, next.End - current.Start, Math.Max(current.Confidence, next.Confidence),
IsSpecial(current.Value) ? next.Value : current.Value);
sorted.Remove(next);
}
}
else if (next.Value == null && current.Overlaps(next))
{
// Remove no preference if there is any overlapping meaning
sorted.Remove(next);
}
}
if (emit && !IsSpecial(current.Value))
{
sorted = (from match in sorted where !current.Covers(match) select match).ToList();
yield return current;
}
}
}
public FindByClassAttribute(TermMatch match, TermCase termCase)
: base(match, termCase)
{
}
protected SelectByAttribute(TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
{
Match = match;
Case = termCase;
}
public FindByClassAttribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public TermFindSettingsAttribute(Type findAttributeType, TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
: base(findAttributeType)
{
Match = match;
Case = termCase;
}
public FindByPlaceholderAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: base(match, termCase)
{
}
protected VerifyHeadingTriggerAttribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public FindByPlaceholderAttribute(TermMatch match, params string[] values)
: base(match, values)
{
}
public FindByAttributeAttribute(string attributeName, TermMatch match, TermCase termCase = TermCase.Inherit)
: this(attributeName, null, match, termCase)
{
}
protected TermFindAttribute(TermMatch match, TermCase termCase = TermCase.Inherit)
: this(null, match, termCase)
{
}
private FindByAttributeAttribute(string attributeName, string[] values = null, TermMatch match = TermMatch.Inherit, TermCase termCase = TermCase.Inherit)
: base(values, match, termCase)
{
AttributeName = attributeName.CheckNotNullOrWhitespace(nameof(attributeName));
}
public static TOwner Contain <TOwner>(this IDataVerificationProvider <IEnumerable <IDataProvider <string, TOwner> >, TOwner> should, TermMatch match, params string[] expected)
{
return(should.Contain(match, expected.AsEnumerable()));
}
