/// <summary> /// Checks whether the supplied <paramref name="method"/> matches the <paramref name="rule"/>. /// </summary> /// <param name="rule">The rule to match against the <paramref name="method"/>.</param> /// <param name="type">The type to check if it matches the <paramref name="rule"/> if /// <see cref="RegexRule.Type"/> is not null.</param> /// <param name="method">The method to check if it matches the <paramref name="rule"/>.</param> /// <returns><see langword="true"/> if the <paramref name="rule"/> matches against the /// <paramref name="method"/>; otherwise <see langword="false"/>.</returns> /// <exception cref="ArgumentNullException">The <paramref name="rule"/>, <paramref name="type"/> or /// <paramref name="method"/> parameters are <see langword="null"/>.</exception> /// <exception cref="ArgumentException">The <see cref="RegexRule.Method"/> property of the /// <paramref name="rule"/> is <see langword="null"/>.</exception> public static bool MatchMethod(this RegexRule rule, Type type, MethodBase method) { if (rule == null) { throw new ArgumentNullException(nameof(rule)); } if (type == null) { throw new ArgumentNullException(nameof(type)); } if (method == null) { throw new ArgumentNullException(nameof(method)); } if (rule.Method == null) { throw new ArgumentException("The rule has a null Method regular expression.", nameof(rule)); } // If there is a type regular expression it must match the type. if (rule.Type != null && !rule.MatchType(type)) { return(false); } return(rule.Method.IsMatch(method.Name)); }
// ReSharper disable UnusedParameter.Local private void AssertMethodRule(Func <string, Type, IRegexFilter> addMethod, MethodBase method, Type type, bool expectedInclude) { IRegexFilter actualFilter = addMethod(method.Name, type); int expectedRules = 1; if (expectedInclude && type != null) { expectedRules++; } Assert.Same(addMethod.Target, actualFilter); Assert.Equal(expectedRules, actualFilter.Rules.Count); RegexRule addedRule = actualFilter.MethodRules.Single(); Assert.Equal(expectedInclude, addedRule.Include); Assert.NotNull(addedRule.Method); Assert.True(addedRule.MatchMethod(type ?? GetType(), method)); Assert.Null(addedRule.Parameter); if (type == null) { Assert.Null(addedRule.Type); } else { Assert.NotNull(addedRule.Type); Assert.True(addedRule.MatchType(type)); } }
public void ThrowIfNoTypeRuleForTypeMatch(Type type) { // Arrange var rule = new RegexRule("Throw rule"); // Act/Assert string paramName = Assert.Throws<ArgumentException>(() => rule.MatchType(type)).ParamName; Assert.Equal("rule", paramName); }
public void ThrowIfNoTypeRuleForTypeMatch(Type type) { // Arrange var rule = new RegexRule("Throw rule"); // Act/Assert string paramName = Assert.Throws <ArgumentException>(() => rule.MatchType(type)).ParamName; Assert.Equal("rule", paramName); }
public void NotMatchAType(Type type) { // Arrange var rule = new RegexRule("Miss rule", type: new Regex("Miss")); // Act bool actual = rule.MatchType(type); // Assert Assert.False(actual); }
public void NotMatchAType(Type type) { // Arrange var rule = new RegexRule("Miss rule", type: new Regex("Miss")); // Act bool actual = rule.MatchType(type); // Assert Assert.False(actual); }
public void MatchAType(Type type) { // Arrange var rule = new RegexRule( type.Name + " hit rule", include: true, type: new Regex(@".+\." + type.Name)); // Act bool actual = rule.MatchType(type); // Assert Assert.True(actual); }
public void MatchAType(Type type) { // Arrange var rule = new RegexRule( type.Name + " hit rule", include: true, type: new Regex(@".+\." + type.Name)); // Act bool actual = rule.MatchType(type); // Assert Assert.True(actual); }
// ReSharper disable UnusedParameter.Local private void AssertTypeRule(Func <Type, IRegexFilter> addMethod, bool expectedInclude) { IRegexFilter actualFilter = addMethod(GetType()); Assert.Same(addMethod.Target, actualFilter); Assert.Single(actualFilter.Rules); RegexRule addedRule = actualFilter.Rules.Single(); Assert.Equal(expectedInclude, addedRule.Include); Assert.NotNull(addedRule.Type); Assert.Null(addedRule.Method); Assert.Null(addedRule.Parameter); Assert.True(addedRule.MatchType(GetType())); }
// ReSharper disable UnusedParameter.Local private void AssertParameterRule(Func <string, Type, string, IRegexFilter> addMethod, ParameterInfo parameter, Type type, MethodBase method, bool expectedInclude) { IRegexFilter actualFilter = addMethod(parameter.Name, type, method == null ? null : method.Name); int expectedRules = 1; if (expectedInclude && method != null) { expectedRules++; } if (expectedInclude && type != null) { expectedRules++; } Assert.Same(addMethod.Target, actualFilter); Assert.Equal(expectedRules, actualFilter.Rules.Count); RegexRule addedRule = actualFilter.ParameterRules.Single(); Assert.Equal(expectedInclude, addedRule.Include); Assert.NotNull(addedRule.Parameter); Assert.True(addedRule.MatchParameter(type ?? GetType(), method ?? new Mock <MethodBase>().Object, parameter)); if (type == null) { Assert.Null(addedRule.Type); } else { Assert.NotNull(addedRule.Type); Assert.True(addedRule.MatchType(type)); } if (method == null) { Assert.Null(addedRule.Method); } else { Assert.NotNull(addedRule.Method); Assert.True(addedRule.MatchMethod(type ?? GetType(), method)); } }
/// <summary> /// Checks whether the supplied <paramref name="parameter"/> matches the <paramref name="rule"/>. /// </summary> /// <param name="rule">The rule to match against the <paramref name="method"/>.</param> /// <param name="type">The type to check if it matches the <paramref name="rule"/> if /// <see cref="RegexRule.Type"/> is not null.</param> /// <param name="method">The method to check if it matches the <paramref name="rule"/> if /// <see cref="RegexRule.Method"/> is not null.</param> /// <param name="parameter">The parameter to check if it matches the <paramref name="rule"/>.</param> /// <returns><see langword="true"/> if the <paramref name="rule"/> matches against the /// <paramref name="parameter"/>; otherwise <see langword="false"/>.</returns> /// <exception cref="ArgumentNullException">The <paramref name="rule"/>, <paramref name="type"/>, /// <paramref name="method"/> or <paramref name="parameter"/> parameters are <see langword="null"/>.</exception> /// <exception cref="ArgumentException">The <see cref="RegexRule.Parameter"/> property of the /// <paramref name="rule"/> is <see langword="null"/>.</exception> public static bool MatchParameter(this RegexRule rule, Type type, MethodBase method, ParameterInfo parameter) { if (rule == null) { throw new ArgumentNullException(nameof(rule)); } if (type == null) { throw new ArgumentNullException(nameof(type)); } if (method == null) { throw new ArgumentNullException(nameof(method)); } if (parameter == null) { throw new ArgumentNullException(nameof(parameter)); } if (rule.Parameter == null) { throw new ArgumentException("The rule has a null Parameter regular expression.", nameof(rule)); } // If there is a method regular expression it must match the method. if (rule.Method != null) { if (!rule.MatchMethod(type, method)) { return(false); } } else if (rule.Type != null && !rule.MatchType(type)) { // If there is a type regular expression but no method it must match the type. return(false); } return(rule.Parameter.IsMatch(parameter.Name)); }