public void Can_Identify_Excluded_Types(string typeName)
{
// arrange
var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Concrete).Assembly.Location);
// act
var filter = new Filter(false);
var allTypes = AllTypes(sourceAssembly.MainModule);
var typeDefinition = allTypes.First(x => x.Name == typeName);
Assert.False(filter.ExcludeByAttribute(typeDefinition));
// assert
filter.AddAttributeExclusionFilters(new[] { "*ExcludeClassAttribute" });
foreach (var methodDefinition in typeDefinition.Methods)
{
if (methodDefinition.IsSetter || methodDefinition.IsGetter)
{
continue;
}
Assert.True(filter.ExcludeByAttribute(methodDefinition));
}
Assert.True(filter.ExcludeByAttribute(typeDefinition));
foreach (var nestedType in AllNestedTypes(typeDefinition))
{
Assert.True(filter.ExcludeByAttribute(nestedType));
}
}
public void AddAttributeExclusionFilters_Escapes_Elements_And_Matches()
{
var filter = new Filter(false);
filter.AddAttributeExclusionFilters(new[] { ".*" });
Assert.IsTrue(filter.ExcludedAttributes[0].IsMatchingExpression(".ABC"));
}
public void AddAttributeExclusionFilters_Handles_Null_Elements()
{
var filter = new Filter(false);
filter.AddAttributeExclusionFilters(new[] { null, "" });
Assert.AreEqual(1, filter.ExcludedAttributes.Count);
}
public void AddAttributeExclusionFilters_HandlesNull()
{
var filter = new Filter(false);
filter.AddAttributeExclusionFilters(null);
Assert.AreEqual(0, filter.ExcludedAttributes.Count);
}
public void AddAttributeExclusionFilters_Escapes_Elements_And_Matches()
{
var filter = new Filter();
filter.AddAttributeExclusionFilters(new[] { ".*" });
Assert.IsTrue(filter.ExcludedAttributes[0].Value.Match(".ABC").Success);
}
public void AddAttributeExclustionFilters_DoesNotWrap_ForRegexFilters()
{
var filter = new Filter(true);
const string stringToMatch = "some string on the line before EXPRESSION some string after the expression";
filter.AddAttributeExclusionFilters(new[] { "EXPRESSION" });
var excludedAttributeRegexFilter = filter.ExcludedAttributes[0];
Assert.IsTrue(excludedAttributeRegexFilter.IsMatchingExpression(stringToMatch));
}
public void Can_Identify_Excluded_Assemblies()
{
// arrange
var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Concrete).Assembly.Location);
// act
var filter = new Filter(false);
Assert.False(filter.ExcludeByAttribute(sourceAssembly));
// assert
filter.AddAttributeExclusionFilters(new[] { "*ExcludeAssemblyAttribute" });
Assert.True(filter.ExcludeByAttribute(sourceAssembly));
}
public void Handles_Issue117()
{
var filter = new Filter(false);
filter.AddAttributeExclusionFilters(new[] { "*ExcludeMethodAttribute" });
var mockDefinition = new Mock <IMemberDefinition>();
mockDefinition.SetupGet(x => x.HasCustomAttributes).Returns(true);
mockDefinition.SetupGet(x => x.CustomAttributes).Returns(new Collection <CustomAttribute>());
mockDefinition.SetupGet(x => x.Name).Returns("<>f_ddd");
mockDefinition.SetupGet(x => x.DeclaringType).Returns(new TypeDefinition("", "f_ddd", TypeAttributes.Public));
Assert.DoesNotThrow(() => filter.ExcludeByAttribute(mockDefinition.Object));
}
public void Can_Identify_Excluded_Properties()
{
var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Concrete).Assembly.Location);
var type = sourceAssembly.MainModule.Types.First(x => x.FullName == typeof(Samples.Concrete).FullName);
var filter = new Filter(false);
filter.AddAttributeExclusionFilters(new[] { "*ExcludeMethodAttribute" });
foreach (var propertyDefinition in type.Properties)
{
Assert.True(filter.ExcludeByAttribute(propertyDefinition));
}
}
public void Can_Identify_Excluded_Methods_UsingRegularExpressions()
{
// arrange
var filter = new Filter(true);
filter.AddAttributeExclusionFilters(new[] { ".*ExcludeMethodAttribute" });
// act
var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Concrete).Assembly.Location);
var type = sourceAssembly.MainModule.Types.First(x => x.FullName == typeof(Samples.Concrete).FullName);
// assert
foreach (var methodDefinition in type.Methods.Where(methodDefinition => !methodDefinition.IsSetter && !methodDefinition.IsGetter))
{
Assert.True(filter.ExcludeByAttribute(methodDefinition));
}
}
private static IFilter BuildFilter(CommandLineParser parser)
{
var filter = new Filter();
// apply filters
if (!parser.NoDefaultFilters)
{
filter.AddFilter("-[mscorlib]*");
filter.AddFilter("-[mscorlib.*]*");
filter.AddFilter("-[System]*");
filter.AddFilter("-[System.*]*");
filter.AddFilter("-[Microsoft.VisualBasic]*");
}
if (parser.Filters.Count == 0 && string.IsNullOrEmpty(parser.FilterFile))
{
filter.AddFilter("+[*]*");
}
else
{
if (!string.IsNullOrEmpty(parser.FilterFile))
{
if (!File.Exists(parser.FilterFile))
{
System.Console.WriteLine("FilterFile '{0}' cannot be found - have you specified your arguments correctly?", parser.FilterFile);
}
else
{
var filters = File.ReadAllLines(parser.FilterFile);
filters.ToList().ForEach(filter.AddFilter);
}
}
if (parser.Filters.Count > 0)
{
parser.Filters.ForEach(filter.AddFilter);
}
}
filter.AddAttributeExclusionFilters(parser.AttributeExclusionFilters.ToArray());
filter.AddFileExclusionFilters(parser.FileExclusionFilters.ToArray());
filter.AddTestFileFilters(parser.TestFilters.ToArray());
return(filter);
}
public void Can_Identify_Included_Anonymous_Issue99()
{
var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Anonymous).Assembly.Location);
var type = sourceAssembly.MainModule.Types.First(x => x.FullName == typeof(Samples.Anonymous).FullName);
var filter = new Filter(false);
filter.AddAttributeExclusionFilters(new[] { "*ExcludeMethodAttribute" });
foreach (var methodDefinition in type.Methods.Where(x => x.Name.Contains("INCLUDE")))
{
if (methodDefinition.IsSetter || methodDefinition.IsGetter || methodDefinition.IsConstructor)
{
continue;
}
Assert.False(filter.ExcludeByAttribute(methodDefinition), "failed to include {0}", methodDefinition.Name);
}
}
public void Can_Identify_Excluded_Methods()
{
var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Concrete).Assembly.Location);
var type = sourceAssembly.MainModule.Types.First(x => x.FullName == typeof(Samples.Concrete).FullName);
var filter = new Filter(false);
filter.AddAttributeExclusionFilters(new[] { "*ExcludeMethodAttribute" });
foreach (var methodDefinition in type.Methods)
{
if (methodDefinition.IsSetter || methodDefinition.IsGetter)
{
continue;
}
Assert.True(filter.ExcludeByAttribute(methodDefinition));
}
}
public void Can_Identify_Excluded_Types()
{
// arrange
var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Concrete).Assembly.Location);
// act
var filter = new Filter();
foreach (var typeDefinition in sourceAssembly.MainModule.Types.Where(x => x.Name == "Concrete"))
{
Assert.False(filter.ExcludeByAttribute(typeDefinition));
}
// assert
filter.AddAttributeExclusionFilters(new[] { "*ExcludeClassAttribute" });
foreach (var typeDefinition in sourceAssembly.MainModule.Types.Where(x => x.Name == "Concrete"))
{
Assert.True(filter.ExcludeByAttribute(typeDefinition));
}
}
