/// <summary>
/// Adds the rule to include or exclude the <paramref name="methodName"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="parameterName">The parameter name.</param>
/// <param name="include">A value indicating whether this is a include or exclude rule.</param>
/// <param name="typeFullName">The <see cref="Type.FullName"/> of the <see cref="Type"/>.</param>
/// <param name="methodName">The method name.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="parameterName"/>
/// parameters are <see langword="null"/>.</exception>
private static IRegexFilter AddParameterRule(
this IRegexFilter filter,
string parameterName,
bool include,
string typeFullName = null,
string methodName = null)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
if (string.IsNullOrWhiteSpace(parameterName))
{
throw new ArgumentNullException(nameof(parameterName));
}
string name = string.Concat(include ? "Include " : "Exclude ", parameterName);
filter.Rules.Add(new RegexRule(
name,
include: include,
type: GetNameRegex(typeFullName),
method: GetNameRegex(methodName),
parameter: GetNameRegex(parameterName)));
return(filter);
}
private static void AssertSingleExcludeAllMethodsRule(IRegexFilter regexFilter)
{
RegexRule regexRule = regexFilter.MethodRules.Single();
Assert.False(regexRule.Include);
Assert.Null(regexRule.Type);
Assert.True(regexRule.Method.IsMatch(Guid.NewGuid().ToString()));
}
private static void AssertSingleExcludeAllTypesRule(IRegexFilter regexFilter)
{
RegexRule regexRule = regexFilter.TypeRules.Single();
Assert.False(regexRule.Include);
Assert.Matches(regexRule.Type, Guid.NewGuid().ToString());
}
/// <summary>
/// Excludes the <paramref name="methodName"/> from checks for <see cref="ArgumentNullException"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="methodName">The method name.</param>
/// <param name="typeFullName">The <see cref="Type.FullName"/> of the <see cref="Type"/>.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="methodName"/>
/// parameters are <see langword="null"/>.</exception>
public static IRegexFilter ExcludeMethod(
this IRegexFilter filter,
string methodName,
string typeFullName = null)
{
return(filter.AddMethodRule(methodName, include: false, typeFullName: typeFullName));
}
// 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));
}
}
/// <summary>
/// Includes the <paramref name="parameterName"/> for checks for <see cref="ArgumentNullException"/>. Overrides
/// any parameter rules that may exclude the <paramref name="parameterName"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="parameterName">The parameter name.</param>
/// <param name="type">The type.</param>
/// <param name="methodName">The method name.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="parameterName"/>
/// parameters are <see langword="null"/>.</exception>
public static IRegexFilter IncludeParameter(
this IRegexFilter filter,
string parameterName,
Type type,
string methodName = null)
{
return(filter.IncludeParameter(parameterName, type != null ? type.FullName : null, methodName));
}
private static void AssertSingleExcludeAllParametersRule(IRegexFilter regexFilter)
{
RegexRule regexRule = regexFilter.ParameterRules.Single();
Assert.False(regexRule.Include);
Assert.Null(regexRule.Type);
Assert.Null(regexRule.Method);
Assert.Matches(regexRule.Parameter, Guid.NewGuid().ToString());
}
/// <summary>
/// Includes the <paramref name="type"/> for checks for <see cref="ArgumentNullException"/>. Overrides any type
/// rules that may exclude the <paramref name="type"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="type">The type.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="type"/> parameters
/// are <see langword="null"/>.</exception>
public static IRegexFilter IncludeType(this IRegexFilter filter, Type type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
return(filter.IncludeType(type.FullName));
}
/// <summary>
/// Excludes the <paramref name="parameterName"/> from checks for <see cref="ArgumentNullException"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="parameterName">The parameter name.</param>
/// <param name="typeFullName">The <see cref="Type.FullName"/> of the <see cref="Type"/>.</param>
/// <param name="methodName">The method name.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="parameterName"/>
/// parameters are <see langword="null"/>.</exception>
public static IRegexFilter ExcludeParameter(
this IRegexFilter filter,
string parameterName,
string typeFullName = null,
string methodName = null)
{
return(filter.AddParameterRule(
parameterName,
include: false,
typeFullName: typeFullName,
methodName: methodName));
}
/// <summary>
/// Excludes all types, methods and parameters.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> parameter is
/// <see langword="null"/>.</exception>
public static IRegexFilter ExcludeAll(this IRegexFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
return
(filter.ExcludeAllTypes()
.ExcludeAllMethods()
.ExcludeAllParameters());
}
/// <summary>
/// Excludes all types, methods and parameters.
/// </summary>
/// <param name="fixture">The fixture.</param>
/// <returns>The <paramref name="fixture"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="fixture"/> parameter is <see langword="null"/>.</exception>
public static IArgumentNullExceptionFixture ExcludeAll(this IArgumentNullExceptionFixture fixture)
{
if (fixture == null)
{
throw new ArgumentNullException(nameof(fixture));
}
IRegexFilter regexFilter = fixture.GetRegexFilter();
regexFilter.ExcludeAll();
return(fixture);
}
/// <summary>
/// Includes the <paramref name="methodName"/> for checks for <see cref="ArgumentNullException"/>. Overrides any
/// method rules that may exclude the <paramref name="methodName"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="methodName">The method name.</param>
/// <param name="typeFullName">The type.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="methodName"/>
/// parameters are <see langword="null"/>.</exception>
public static IRegexFilter IncludeMethod(
this IRegexFilter filter,
string methodName,
string typeFullName = null)
{
// If the type is specified ensure it is included otherwise the
// method may never be included.
if (!string.IsNullOrWhiteSpace(typeFullName))
{
filter.IncludeType(typeFullName);
}
return(filter.AddMethodRule(methodName, include: true, typeFullName: typeFullName));
}
// 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()));
}
/// <summary>
/// Excludes all types, methods and parameters.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> parameter is
/// <see langword="null"/>.</exception>
public static IRegexFilter ExcludeAllParameters(this IRegexFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
filter.Rules.Add(new RegexRule(
"Exclude all parameters",
include: false,
parameter: MatchAll));
return(filter);
}
public void ExcludeAllParameters()
{
// Arrange
var sut = new RegexFilter();
// Act
IRegexFilter result = sut.ExcludeAllParameters();
// Assert
Assert.Same(sut, result);
Assert.Single(sut.Rules);
RegexRule parameterRule = sut.ParameterRules.Single();
Assert.Matches(parameterRule.Parameter, Guid.NewGuid().ToString());
}
public void ExcludeAllMethods()
{
// Arrange
var sut = new RegexFilter();
// Act
IRegexFilter result = sut.ExcludeAllMethods();
// Assert
Assert.Same(sut, result);
Assert.Single(sut.Rules);
RegexRule methodRule = sut.MethodRules.Single();
Assert.Matches(methodRule.Method, Guid.NewGuid().ToString());
}
/// <summary>
/// Includes the <paramref name="typeFullName"/> for checks for <see cref="ArgumentNullException"/>.
/// Overrides any type rules that may exclude the <paramref name="typeFullName"/>.
/// </summary>
/// <param name="fixture">The fixture.</param>
/// <param name="typeFullName">The <see cref="Type.FullName"/> of the <see cref="Type"/>.</param>
/// <returns>The <paramref name="fixture"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="fixture"/> or <paramref name="typeFullName"/>
/// parameters are <see langword="null"/>.</exception>
public static IArgumentNullExceptionFixture IncludeType(this IArgumentNullExceptionFixture fixture, string typeFullName)
{
if (fixture == null)
{
throw new ArgumentNullException(nameof(fixture));
}
if (string.IsNullOrWhiteSpace(typeFullName))
{
throw new ArgumentNullException(nameof(typeFullName));
}
IRegexFilter regexFilter = fixture.GetRegexFilter();
regexFilter.IncludeType(typeFullName);
return(fixture);
}
public void ExcludeNone(
ExcludeAllAttribute sut,
MethodInfo method)
{
// Arrange
sut.ExclusionType = ExclusionType.None;
var fixture = new ArgumentNullExceptionFixture(GetType().GetTypeInfo().Assembly);
IArgNullExCustomization customization = sut.GetCustomization(method);
// Act
customization.Customize(fixture);
// Assert
IRegexFilter regexFilter = fixture.Filters.OfType <IRegexFilter>().Single();
Assert.Empty(regexFilter.Rules);
}
/// <summary>
/// Gets the single <see cref="IRegexFilter"/> from the <see cref="IArgumentNullExceptionFixture.Filters"/>.
/// </summary>
/// <param name="fixture">The fixture.</param>
/// <returns>The single <see cref="IRegexFilter"/> from the <see cref="IArgumentNullExceptionFixture.Filters"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="fixture"/> parameter is <see langword="null"/>.</exception>
/// <exception cref="InvalidOperationException">There are zero of more than one <see cref="IRegexFilter"/> objects in the <see cref="IArgumentNullExceptionFixture.Filters"/>.</exception>
private static IRegexFilter GetRegexFilter(this IArgumentNullExceptionFixture fixture)
{
if (fixture == null)
{
throw new ArgumentNullException(nameof(fixture));
}
IRegexFilter regexFilter =
fixture.Filters
.OfType <IRegexFilter>()
.SingleOrDefault();
if (regexFilter == null)
{
throw new InvalidOperationException("There is no IRegexFilter in the filters.");
}
return(regexFilter);
}
// 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));
}
}
public void ExcludeAllMethods(
ExcludeAllAttribute sut,
MethodInfo method)
{
// Arrange
sut.ExclusionType = ExclusionType.Methods;
var fixture = new ArgumentNullExceptionFixture(GetType().GetTypeInfo().Assembly);
IArgNullExCustomization customization = sut.GetCustomization(method);
// Act
customization.Customize(fixture);
IEnumerable <MethodData> data = fixture.GetData();
// Assert
Assert.Empty(data);
IRegexFilter regexFilter = fixture.Filters.OfType <IRegexFilter>().Single();
Assert.Single(regexFilter.Rules);
AssertSingleExcludeAllMethodsRule(regexFilter);
}
/// <summary>
/// Excludes the <paramref name="methodName"/> from checks for <see cref="ArgumentNullException"/>.
/// </summary>
/// <param name="fixture">The fixture.</param>
/// <param name="methodName">The method name.</param>
/// <param name="typeFullName">The <see cref="Type.FullName"/> of the <see cref="Type"/>.</param>
/// <returns>The <paramref name="fixture"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="fixture"/> or <paramref name="methodName"/>
/// parameters are <see langword="null"/>.</exception>
public static IArgumentNullExceptionFixture ExcludeMethod(
this IArgumentNullExceptionFixture fixture,
string methodName,
string typeFullName = null)
{
if (fixture == null)
{
throw new ArgumentNullException(nameof(fixture));
}
if (string.IsNullOrWhiteSpace(methodName))
{
throw new ArgumentNullException(nameof(methodName));
}
IRegexFilter regexFilter = fixture.GetRegexFilter();
regexFilter.ExcludeMethod(methodName, typeFullName);
return(fixture);
}
public void ExcludeAll()
{
// Arrange
var sut = new RegexFilter();
// Act
IRegexFilter result = sut.ExcludeAll();
// Assert
Assert.Same(sut, result);
Assert.Equal(3, sut.Rules.Count);
RegexRule typeRule = sut.TypeRules.Single();
Assert.Matches(typeRule.Type, Guid.NewGuid().ToString());
RegexRule methodRule = sut.MethodRules.Single();
Assert.Matches(methodRule.Method, Guid.NewGuid().ToString());
RegexRule parameterRule = sut.ParameterRules.Single();
Assert.Matches(parameterRule.Parameter, Guid.NewGuid().ToString());
}
/// <summary>
/// Includes the <paramref name="parameterName"/> for checks for <see cref="ArgumentNullException"/>. Overrides
/// any parameter rules that may exclude the <paramref name="parameterName"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="parameterName">The parameter name.</param>
/// <param name="typeFullName">The <see cref="Type.FullName"/> of the <see cref="Type"/>.</param>
/// <param name="methodName">The method name.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="parameterName"/>
/// parameters are <see langword="null"/>.</exception>
public static IRegexFilter IncludeParameter(
this IRegexFilter filter,
string parameterName,
string typeFullName = null,
string methodName = null)
{
// If the method or type type is specified ensure they are included
// otherwise the parameter may never be included.
if (!string.IsNullOrWhiteSpace(methodName))
{
filter.IncludeMethod(methodName, typeFullName);
}
else if (!string.IsNullOrWhiteSpace(typeFullName))
{
filter.IncludeType(typeFullName);
}
return(filter.AddParameterRule(
parameterName,
include: true,
typeFullName: typeFullName,
methodName: methodName));
}
/// <summary>
/// Excludes the <paramref name="methodName"/> from checks for <see cref="ArgumentNullException"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="methodName">The method name.</param>
/// <param name="type">The type.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="methodName"/>
/// parameters are <see langword="null"/>.</exception>
public static IRegexFilter ExcludeMethod(this IRegexFilter filter, string methodName, Type type)
{
return(filter.ExcludeMethod(methodName, type != null ? type.FullName : null));
}
/// <summary>
/// Includes the <paramref name="typeFullName"/> for checks for <see cref="ArgumentNullException"/>. Overrides
/// any type rules that may exclude the <paramref name="typeFullName"/>.
/// </summary>
/// <param name="filter">The <see cref="Regex"/> filter.</param>
/// <param name="typeFullName">The <see cref="Type.FullName"/> of the <see cref="Type"/>.</param>
/// <returns>The <paramref name="filter"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="filter"/> or <paramref name="typeFullName"/>
/// parameters are <see langword="null"/>.</exception>
public static IRegexFilter IncludeType(this IRegexFilter filter, string typeFullName)
{
return(filter.AddTypeRule(typeFullName, include: true));
}