protected void VerifyNavigateToResultItem( NavigateToItem result, string name, string displayMarkup, MatchKind matchKind, string navigateToItemKind, string additionalInfo = null) { // Verify symbol information Assert.Equal(name, result.Name); Assert.Equal(matchKind, result.MatchKind); Assert.Equal(this.Language, result.Language); Assert.Equal(navigateToItemKind, result.Kind); MarkupTestFile.GetSpans(displayMarkup, out displayMarkup, out ImmutableArray <TextSpan> expectedDisplayNameSpans); var itemDisplay = (AbstractNavigateToItemDisplay)result.DisplayFactory.CreateItemDisplay(result); Assert.Equal(displayMarkup, itemDisplay.Name); Assert.Equal <TextSpan>( expectedDisplayNameSpans, itemDisplay.GetNameMatchRuns("").Select(s => s.ToTextSpan()).ToImmutableArray()); if (additionalInfo != null) { Assert.Equal(additionalInfo, itemDisplay.AdditionalInformation); } // Make sure to fetch the glyph var unused = itemDisplay.Glyph; _glyphServiceMock.Verify(); }
public Method(Type parent, string name, MatchKind match, MethodAction?action = null) { Parent = parent; Name = name; Match = match; Action = action; }
public FilepathTextMatchFilter(ObjectListView olv, string text, MatchKind match) : base(olv, text, match, StringComparison.CurrentCultureIgnoreCase) { this.Columns = new OLVColumn[]{ (OLVColumn)olv.Columns[1] }; }
protected TagMatchCondition(IDeserializer deserializer) : base(deserializer) { MatchScopes = deserializer.GetValue <TagScope>(nameof(MatchScopes)); MatchKey = deserializer.GetValue <string>(nameof(MatchKey)); KeyMatchKind = deserializer.GetValue <MatchKind>(nameof(KeyMatchKind)); }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { // If we are the last operation, don't match if (operatorIndex == operators.Count - 1) return -1; // If we reach the end of the "path", or we are not on a path separator, don't match if (pathIndex == path.Length || !FileNameMatching.IsPathSeparator(path[pathIndex])) return -1; pathIndex++; while (pathIndex < path.Length) { var result = Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex); if (result == path.Length) return result; // Look for next path separator in path var nextPathIndex = path.IndexOf(Path.DirectorySeparatorChar, pathIndex, path.Length - pathIndex); if (nextPathIndex < 0) break; pathIndex = nextPathIndex + 1; } return -1; }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { var result = Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex); if (kind == MatchKind.File && result == path.Length) return -1; return result; }
public static bool IsMatch(string test, string match, MatchKind matchKind, bool isCaseSensitive) { var compareInfo = CultureInfo.CurrentCulture.CompareInfo; var options = isCaseSensitive ? CompareOptions.None : CompareOptions.IgnoreCase; switch (matchKind) { case MatchKind.Exact: return(compareInfo.Compare(test, match, options) == 0); case MatchKind.Contains: return(compareInfo.IndexOf(test, match, options) != -1); case MatchKind.Prefix: return(compareInfo.IsPrefix(test, match, options)); case MatchKind.Suffix: return(compareInfo.IsSuffix(test, match, options)); case MatchKind.Regex: { var regex = new Regex(match, isCaseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase); return(regex.IsMatch(test)); } default: throw new NotImplementedException($"Unhandled MatchKind: {matchKind}"); } }
internal void VerifyNavigateToResultItem( NavigateToItem result, string name, string displayMarkup, MatchKind matchKind, string navigateToItemKind, Glyph glyph, string additionalInfo = null) { // Verify symbol information Assert.Equal(name, result.Name); Assert.Equal(matchKind, result.MatchKind); Assert.Equal(this.Language, result.Language); Assert.Equal(navigateToItemKind, result.Kind); MarkupTestFile.GetSpans(displayMarkup, out displayMarkup, out ImmutableArray <TextSpan> expectedDisplayNameSpans); var itemDisplay = (NavigateToItemDisplay)result.DisplayFactory.CreateItemDisplay(result); Assert.Equal(itemDisplay.GlyphMoniker, glyph.GetImageMoniker()); Assert.Equal(displayMarkup, itemDisplay.Name); Assert.Equal <TextSpan>( expectedDisplayNameSpans, itemDisplay.GetNameMatchRuns("").Select(s => s.ToTextSpan()).ToImmutableArray()); if (additionalInfo != null) { Assert.Equal(additionalInfo, itemDisplay.AdditionalInformation); } }
private void VerifyNavigateToResultItem(NavigateToItem result, string name, MatchKind matchKind, string navigateToItemKind, string displayName = " ", string additionalInfo = " ") { string itemDisplayName; // Verify symbol information Assert.Equal(name, result.Name); Assert.Equal(matchKind, result.MatchKind); Assert.Equal("csharp", result.Language); Assert.Equal(navigateToItemKind, result.Kind); // Verify display var itemDisplay = result.DisplayFactory.CreateItemDisplay(result); itemDisplayName = string.IsNullOrWhiteSpace(displayName) ? name : displayName; Assert.Equal(itemDisplayName, itemDisplay.Name); if (!string.IsNullOrWhiteSpace(additionalInfo)) { Assert.Equal(additionalInfo, itemDisplay.AdditionalInformation); } // Make sure to fetch the glyph var unused = itemDisplay.Glyph; _glyphServiceMock.Verify(); }
public FilepathTextMatchFilter(ObjectListView olv, string text, MatchKind match) : base(olv, text, match, StringComparison.CurrentCultureIgnoreCase) { this.Columns = new OLVColumn[] { (OLVColumn)olv.Columns[1] }; }
public SearchResult(Document document, DeclaredSymbolInfo declaredSymbolInfo, string kind, MatchKind matchKind, bool isCaseSensitive, INavigableItem navigableItem) { _document = document; _declaredSymbolInfo = declaredSymbolInfo; Kind = kind; MatchKind = matchKind; IsCaseSensitive = isCaseSensitive; NavigableItem = navigableItem; SecondarySort = ConstructSecondarySortString(declaredSymbolInfo); var declaredNavigableItem = navigableItem as NavigableItemFactory.DeclaredSymbolNavigableItem; Debug.Assert(declaredNavigableItem != null); _lazySummary = new Lazy<string>(() => declaredNavigableItem.Symbol?.GetDocumentationComment()?.SummaryText); _lazyAdditionalInfo = new Lazy<string>(() => { switch (declaredSymbolInfo.Kind) { case DeclaredSymbolInfoKind.Class: case DeclaredSymbolInfoKind.Enum: case DeclaredSymbolInfoKind.Interface: case DeclaredSymbolInfoKind.Module: case DeclaredSymbolInfoKind.Struct: return EditorFeaturesResources.Project + document.Project.Name; default: return EditorFeaturesResources.Type + declaredSymbolInfo.ContainerDisplayName; } }); }
private IEnumerable<NavigateToItem> FilterResults( string projectName, IEnumerable<AP.Completion> completions, IEnumerable<Tuple<FuzzyStringMatcher, string, MatchKind>> matchers ) { foreach (var c in completions) { MatchKind matchKind = MatchKind.None; foreach (var m in matchers) { if (m.Item1.IsCandidateMatch(c.name, m.Item2)) { matchKind = m.Item3; break; } } if (matchKind == MatchKind.None) { continue; } var itemTag = new ItemTag { Site = _serviceProvider, Completion = c, GlyphService = _glyphService, ProjectName = projectName }; yield return new NavigateToItem( c.name, c.memberType.ToString(), "Python", "", itemTag, matchKind, PythonNavigateToItemDisplayFactory.Instance ); } }
public SearchResult(Document document, DeclaredSymbolInfo declaredSymbolInfo, string kind, MatchKind matchKind, bool isCaseSensitive, INavigableItem navigableItem) { _document = document; _declaredSymbolInfo = declaredSymbolInfo; Kind = kind; MatchKind = matchKind; IsCaseSensitive = isCaseSensitive; NavigableItem = navigableItem; SecondarySort = ConstructSecondarySortString(declaredSymbolInfo); var declaredNavigableItem = navigableItem as NavigableItemFactory.DeclaredSymbolNavigableItem; Debug.Assert(declaredNavigableItem != null); _lazySummary = new Lazy <string>(() => declaredNavigableItem.Symbol?.GetDocumentationComment()?.SummaryText); _lazyAdditionalInfo = new Lazy <string>(() => { switch (declaredSymbolInfo.Kind) { case DeclaredSymbolInfoKind.Class: case DeclaredSymbolInfoKind.Enum: case DeclaredSymbolInfoKind.Interface: case DeclaredSymbolInfoKind.Module: case DeclaredSymbolInfoKind.Struct: return(EditorFeaturesResources.Project + document.Project.Name); default: return(EditorFeaturesResources.Type + declaredSymbolInfo.ContainerDisplayName); } }); }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList <BaseOperator> operators, int operatorIndex, string path, int pathIndex) { // Heuristic: If last operator, there is a full match (since "*" at the // end matches everything) if (operatorIndex == operators.Count - 1) { if (path.IndexOf(Path.DirectorySeparatorChar, pathIndex) < 0) { return(path.Length); } return(-1); } // Heuristic for "*[a-z]+": // * if we are matching a file name and // * if there are not path separators after "pathIndex" and // * if the only operator after us is "OpText" // * then we only need to check that path end with the text. if (kind == MatchKind.File) { if (path.IndexOf(Path.DirectorySeparatorChar, pathIndex) < 0) { if (operatorIndex + 1 == operators.Count - 1) { var opText = operators[operatorIndex + 1] as OpText; if (opText != null) { if (comparer.EndsWith(path, opText.Text)) { var remaining = path.Length - pathIndex; if (remaining >= opText.Text.Length) { return(path.Length); } } return(-1); } } } } // Full "*" semantics: any character except "/" for (var i = pathIndex; i < path.Length; i++) { // If we reach "/", move on to next operator if (FileNameMatching.IsPathSeparator(path[i])) { return(Match(kind, comparer, operators, operatorIndex + 1, path, i)); } var result = Match(kind, comparer, operators, operatorIndex + 1, path, i); if (result == path.Length) { return(result); } } return(-1); }
public Type(Type parent, string name, string fullName, MatchKind match, TypeAction?action = null) { Parent = parent; Name = name; FullName = fullName; Match = match; Action = action; }
private void radbtnRegex_Click(object sender, EventArgs e) { if (this._kind != MatchKind.Regex) { this._kind = MatchKind.Regex; this.TimedFilter(this.ListView, this.tbFind.Text); } }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList <BaseOperator> operators, int operatorIndex, string path, int pathIndex) { if (pathIndex < path.Length && path[pathIndex] == Path.DirectorySeparatorChar) { return(Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex + 1)); } return(-1); }
public void RemoveTags(string key, MatchKind keyMatchKind) { var tagKeys = string.Join(", ", m_tags.Where(x => MatchKindUtility.IsMatch(x.Key, key, keyMatchKind, false)).Select(x => x.Key)); Log.Info($"Removing tag from {Owner.RenderForLog()}: '{tagKeys}'."); m_tags.RemoveAll(x => MatchKindUtility.IsMatch(x.Key, key, keyMatchKind, false)); }
private bool PrePassWontMatch(MatchKind kind, string path, IPathComparer comparer) { // Note: Use a "for" loop to avoid allocation with "Any" for (var index = 0; index < _prePassOperators.Length; index++) { if (_prePassOperators[index].PrePassWontMatch(kind, path, comparer)) return true; } return false; }
/// <summary> /// Create a TextFilter /// </summary> /// <param name="olv"></param> /// <param name="text"></param> /// <param name="columns"></param> /// <param name="matchKind"></param> /// <param name="comparison"></param> public TextMatchFilter(ObjectListView olv, string text, OLVColumn[] columns, MatchKind matchKind, StringComparison comparison) { this.ListView = olv; this.Text = text; this.Match = matchKind; this.StringComparison = comparison; this.Columns = columns; }
public MatchInfo(string name, string?value, MatchKind kind) { _ = string.IsNullOrWhiteSpace(name) ? throw new ArgumentException($"{nameof(name)} should not be null or empty") : false; Name = name; Value = value; Kind = kind; }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { var len = _text.Length; if (comparer.Compare(_text, 0, path, pathIndex, len) != 0) return -1; return Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex + len); }
public CopyTagsEffect(string tagKey, MatchKind tagKeyMatchKind, TagScope tagScope, ConditionBase condition, string newTagKey, KeyConflictResolutionKind conflictResolution, EffectTarget target) : base(condition, target) { TagKey = tagKey; TagKeyMatchKind = tagKeyMatchKind; TagScope = tagScope; NewTagKey = newTagKey; ConflictResolution = conflictResolution; }
private CopyTagsEffectViewModel(string tagKey, MatchKind tagKeyMatchKind, TagScope tagScope, string newTagKey, KeyConflictResolutionKind conflictResolution, ConditionViewModelBase condition, EffectTarget target) : base(condition, target) { m_tagKey = tagKey; m_tagKeyMatchKind = tagKeyMatchKind; m_tagScope = tagScope; m_newTagKey = newTagKey; m_conflictResolution = conflictResolution; }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList <BaseOperator> operators, int operatorIndex, string path, int pathIndex) { var result = Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex); if (kind == MatchKind.File && result == path.Length) { return(-1); } return(result); }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList <BaseOperator> operators, int operatorIndex, string path, int pathIndex) { var len = _text.Length; if (String.Compare(_text, 0, path, pathIndex, len, comparer.Comparison) != 0) { return(-1); } return(Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex + len)); }
private bool PrePassWontMatch(MatchKind kind, string path, IPathComparer comparer) { // Note: Use a "for" loop to avoid allocation with "Any" for (var index = 0; index < _prePassOperators.Length; index++) { if (_prePassOperators[index].PrePassWontMatch(kind, path, comparer)) { return(true); } } return(false); }
/// <summary> /// Returns -1 if "path" does not conform to the pattern defined by "operators" /// Returns the index of the first character "path" which does not match the pattern. /// This means that if "index" == "path.Length", the whole path matches the pattern. /// </summary> public static int Match(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { if (operatorIndex > operators.Count) throw new ArgumentException("operator index outside of bounds.", "operatorIndex"); if (pathIndex > path.Length) throw new ArgumentException("path index outside of bounds.", "pathIndex"); // If we reach past the last operator, it means "we matched until this point". if (operatorIndex == operators.Count) return pathIndex; return operators[operatorIndex].MatchWorker(kind, comparer, operators, operatorIndex, path, pathIndex); }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { while (pathIndex < path.Length) { var result = Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex); if (result >= 0) return result; // Look for next path separator in path var nextPathIndex = path.IndexOf(Path.DirectorySeparatorChar, pathIndex, path.Length - pathIndex); if (nextPathIndex < 0) break; pathIndex = nextPathIndex + 1; } return -1; }
protected static void SetName(XElement element, string name, MatchKind match) { switch (match) { case MatchKind.Substring: element.SetAttributeValue("substring", name); break; case MatchKind.FullName: element.SetAttributeValue("fullname", name); break; default: element.SetAttributeValue("name", name); break; } }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { // Heuristic: If last operator, there is a full match (since "*" at the // end matches everything) if (operatorIndex == operators.Count - 1) { if (path.IndexOf(Path.DirectorySeparatorChar, pathIndex) < 0) return path.Length; return -1; } // Heuristic for "*[a-z]+": // * if we are matching a file name and // * if there are not path separators after "pathIndex" and // * if the only operator after us is "OpText" // * then we only need to check that path end with the text. if (kind == MatchKind.File) { if (path.IndexOf(Path.DirectorySeparatorChar, pathIndex) < 0) { if (operatorIndex + 1 == operators.Count - 1) { var opText = operators[operatorIndex + 1] as OpText; if (opText != null) { if (comparer.EndsWith(path, opText.Text)) { var remaining = path.Length - pathIndex; if (remaining >= opText.Text.Length) return path.Length; } return -1; } } } } // Full "*" semantics: any character except "/" for (var i = pathIndex; i < path.Length; i++) { // If we reach "/", move on to next operator if (FileNameMatching.IsPathSeparator(path[i])) return Match(kind, comparer, operators, operatorIndex + 1, path, i); var result = Match(kind, comparer, operators, operatorIndex + 1, path, i); if (result == path.Length) return result; } return -1; }
/// <summary> /// Returns -1 if "path" does not conform to the pattern defined by "operators" /// Returns the index of the first character "path" which does not match the pattern. /// This means that if "index" == "path.Length", the whole path matches the pattern. /// </summary> public static int Match(MatchKind kind, IPathComparer comparer, IList <BaseOperator> operators, int operatorIndex, string path, int pathIndex) { if (operatorIndex > operators.Count) { throw new ArgumentException("operator index outside of bounds.", "operatorIndex"); } if (pathIndex > path.Length) { throw new ArgumentException("path index outside of bounds.", "pathIndex"); } // If we reach past the last operator, it means "we matched until this point". if (operatorIndex == operators.Count) { return(pathIndex); } return(operators[operatorIndex].MatchWorker(kind, comparer, operators, operatorIndex, path, pathIndex)); }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList <BaseOperator> operators, int operatorIndex, string path, int pathIndex) { while (pathIndex < path.Length) { var result = Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex); if (result >= 0) { return(result); } // Look for next path separator in path var nextPathIndex = path.IndexOf(Path.DirectorySeparatorChar, pathIndex, path.Length - pathIndex); if (nextPathIndex < 0) { break; } pathIndex = nextPathIndex + 1; } return(-1); }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { // Heuristic: If last operator, there is a full match (since "*" at the end matches everything) if (operatorIndex == operators.Count - 1) return path.Length; // Heuristic: // * if we are matching a file name // * if there are not path separators after "pathIndex" // * if the only operator after us is "OpText", and // * then we only need to check that path end with the text. if (kind == MatchKind.File) { if (path.IndexOf(Path.DirectorySeparatorChar, pathIndex) < 0) { if (operatorIndex + 1 == operators.Count - 1) { var opText = operators[operatorIndex + 1] as OpText; if (opText != null) { if (path.EndsWith(opText.Text, comparer.Comparison)) { var remaining = path.Length - pathIndex; if (remaining >= opText.Text.Length) return path.Length; } return -1; } } } } // Full "*" semantics (recursive...) for (var i = pathIndex; i < path.Length; i++) { // Stop at first path separator if (FileNameMatching.IsPathSeparator(path[i])) break; var result = Match(kind, comparer, operators, operatorIndex + 1, path, i); if (result == path.Length) return result; } return -1; }
bool GetName(XPathNavigator nav, out string name, out MatchKind match) { name = GetAttribute(nav, "name"); var fullname = GetAttribute(nav, "fullname"); var substring = GetAttribute(nav, "substring"); if (fullname != null) { match = MatchKind.FullName; if (name != null || substring != null) { return(false); } name = fullname; } else if (name != null) { match = MatchKind.Name; if (fullname != null || substring != null) { return(false); } } else if (substring != null) { match = MatchKind.Substring; if (name != null || fullname != null) { return(false); } name = substring; } else { match = MatchKind.Name; return(false); } return(true); }
private static void AssertMatch(MatchKind kind, object[,] expectedResults, bool optimize) { Debug.WriteLine(string.Format("====================================================================")); Debug.WriteLine(string.Format("Verifying expected result for {0} entries with optimization={1}.", expectedResults.GetLength(0), optimize)); Debug.WriteLine(string.Format("====================================================================")); for (var i = 0; i < expectedResults.GetLength(0); i++) { var pattern = (string)expectedResults[i, 0]; var path = (string)expectedResults[i, 1]; var result = (bool)expectedResults[i, 2]; Debug.WriteLine(string.Format("Matching \"{0}\" pattern \"{1}\" against path \"{2}\" should return {3}.", kind, pattern, path, result)); pattern = pattern.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar); path = path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar); IPathMatcher matcher; if (optimize) { matcher = new AggregatePathMatcher(Enumerable.Repeat(PatternParser.ParsePattern(pattern), 1)); } else { matcher = PatternParser.ParsePattern(pattern); } if (kind == MatchKind.Directory) { Assert.AreEqual(result, matcher.MatchDirectoryName(path, SystemPathComparer.Instance)); } else { Assert.AreEqual(result, matcher.MatchFileName(path, SystemPathComparer.Instance)); } } }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList <BaseOperator> operators, int operatorIndex, string path, int pathIndex) { // If we are the last operation, don't match if (operatorIndex == operators.Count - 1) { return(-1); } // If we reach the end of the "path", or we are not on a path separator, don't match if (pathIndex == path.Length || !FileNameMatching.IsPathSeparator(path[pathIndex])) { return(-1); } pathIndex++; while (pathIndex < path.Length) { var result = Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex); if (result == path.Length) { return(result); } // Look for next path separator in path var nextPathIndex = path.IndexOf(Path.DirectorySeparatorChar, pathIndex, path.Length - pathIndex); if (nextPathIndex < 0) { break; } pathIndex = nextPathIndex + 1; } return(-1); }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { if (pathIndex < path.Length && path[pathIndex] == Path.DirectorySeparatorChar) return Match(kind, comparer, operators, operatorIndex + 1, path, pathIndex + 1); return -1; }
protected void VerifyNavigateToResultItem(NavigateToItem result, string name, MatchKind matchKind, string navigateToItemKind, string displayName = null, string additionalInfo = null) { // Verify symbol information Assert.Equal(name, result.Name); Assert.Equal(matchKind, result.MatchKind); Assert.Equal(this.Language, result.Language); Assert.Equal(navigateToItemKind, result.Kind); // Verify display var itemDisplay = result.DisplayFactory.CreateItemDisplay(result); Assert.Equal(displayName ?? name, itemDisplay.Name); if (additionalInfo != null) { Assert.Equal(additionalInfo, itemDisplay.AdditionalInformation); } // Make sure to fetch the glyph var unused = itemDisplay.Glyph; _glyphServiceMock.Verify(); }
private static void AssertMatch(MatchKind kind, object[,] expectedResults) { AssertMatch(kind, expectedResults, false); AssertMatch(kind, expectedResults, true); }
public bool PrePassWontMatch(MatchKind kind, string path, IPathComparer comparer) { return comparer.IndexOf(path, _text, 0, path.Length) < 0; }
public bool PrePassWontMatch(MatchKind kind, string path, IPathComparer comparer) { return(path.IndexOf(_text, 0, path.Length, comparer.Comparison) < 0); }
/// <summary> /// Create a TextFilter /// </summary> /// <param name="olv"></param> /// <param name="text"></param> /// <param name="match"></param> /// <param name="comparison"></param> public TextMatchFilter(ObjectListView olv, string text, MatchKind match, StringComparison comparison) : this(olv, text, null, match, comparison) { }
private void VerifyNavigateToResultItem(NavigateToItem result, string name, MatchKind matchKind, string navigateToItemKind, string displayName = null, string additionalInfo = null) { // Verify symbol information Assert.Equal(name, result.Name); Assert.Equal(matchKind, result.MatchKind); Assert.Equal("csharp", result.Language); Assert.Equal(navigateToItemKind, result.Kind); // Verify display var itemDisplay = result.DisplayFactory.CreateItemDisplay(result); Assert.Equal(displayName ?? name, itemDisplay.Name); if (additionalInfo != null) { Assert.Equal(additionalInfo, itemDisplay.AdditionalInformation); } // Make sure to fetch the glyph var unused = itemDisplay.Glyph; _glyphServiceMock.Verify(); }
private static void AssertMatch(MatchKind kind, object[,] expectedResults, bool optimize) { Debug.WriteLine(string.Format("====================================================================")); Debug.WriteLine(string.Format("Verifying expected result for {0} entries with optimization={1}.", expectedResults.GetLength(0), optimize)); Debug.WriteLine(string.Format("====================================================================")); for (var i = 0; i < expectedResults.GetLength(0); i++) { var pattern = (string)expectedResults[i, 0]; var path = (string)expectedResults[i, 1]; var result = (bool)expectedResults[i, 2]; Debug.WriteLine(string.Format("Matching \"{0}\" pattern \"{1}\" against path \"{2}\" should return {3}.", kind, pattern, path, result)); pattern = pattern.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar); path = path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar); IPathMatcher matcher; if (optimize) { matcher = new AggregatePathMatcher(Enumerable.Repeat(PatternParser.ParsePattern(pattern), 1)); } else { matcher = PatternParser.ParsePattern(pattern); } if (kind == MatchKind.Directory) Assert.AreEqual(result, matcher.MatchDirectoryName(path, SystemPathComparer.Instance)); else Assert.AreEqual(result, matcher.MatchFileName(path, SystemPathComparer.Instance)); } }
/// <summary> /// Create a TextFilter /// </summary> /// <param name="olv"></param> /// <param name="text"></param> /// <param name="match"></param> public TextMatchFilter(ObjectListView olv, string text, MatchKind match) : this(olv, text, null, match, StringComparison.InvariantCultureIgnoreCase) { }
public bool PrePassWontMatch(MatchKind kind, string path, IPathComparer comparer) { return true; }
public override int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex) { return -1; }
public abstract int MatchWorker(MatchKind kind, IPathComparer comparer, IList<BaseOperator> operators, int operatorIndex, string path, int pathIndex);
public bool PrePassWontMatch(MatchKind kind, string path, IPathComparer comparer) { return path.IndexOf(_text, 0, path.Length, comparer.Comparison) < 0; }