exclude nested types when declared type is excluded OpenCover#328

sawilde · Aug 8, 2015 · 66b0344 · 66b0344
1 parent 95495b7
commit 66b0344
Show file tree

Hide file tree

Showing 4 changed files with 75 additions and 12 deletions.
diff --git a/ReleaseNotes.tmp b/ReleaseNotes.tmp
@@ -1,6 +1,7 @@
 Version [[version]]
 #329 address ArgumentOutOfRangeException (potentially related to #274) (fix for VS2015)
 #335 error on unrecognized arguments/prefixes (fix)
+#328 exclude types when declaredtype is excluded (fix-feature)
 
 Version 4.6.166
 #323 push releases and candidates to github via appveyor (prj-mgmt)

diff --git a/main/OpenCover.Framework/Filter.cs b/main/OpenCover.Framework/Filter.cs
@@ -153,10 +153,13 @@ public bool ExcludeByAttribute(IMemberDefinition entity)
 
             while (true)
             {
-                if (entity == null || !entity.HasCustomAttributes)
+                if (entity == null)
                     return false;
 
-                if (ExcludeByAttribute((ICustomAttributeProvider) entity))
+                if (ExcludeByAttribute((ICustomAttributeProvider)entity))
+                    return true;
+
+                if (ExcludeByAttribute(entity.DeclaringType))
                     return true;
 
                 if (entity.DeclaringType == null || !entity.Name.StartsWith("<"))

diff --git a/main/OpenCover.Test/Framework/FilterTests.cs b/main/OpenCover.Test/Framework/FilterTests.cs
@@ -600,24 +600,58 @@ public void Can_Identify_Excluded_Assemblies()
             Assert.True(filter.ExcludeByAttribute(sourceAssembly));
         }
 
+        static IEnumerable<TypeDefinition> AllNestedTypes(TypeDefinition typeDefinition)
+        {
+            if (typeDefinition.NestedTypes == null) yield break;
+            foreach (var nestedTypeDefinition in typeDefinition.NestedTypes)
+            {
+                yield return nestedTypeDefinition;
+                foreach (var allNestedType in AllNestedTypes(nestedTypeDefinition))
+                {
+                    yield return allNestedType;
+                }
+            }
+        }
+
+        static IEnumerable<TypeDefinition> AllTypes(ModuleDefinition module)
+        {
+            foreach (var typeDefinition in module.Types)
+            {
+                yield return typeDefinition;
+                foreach (var allNestedType in AllNestedTypes(typeDefinition))
+                {
+                    yield return allNestedType;
+                }
+            }
+        }
+
         [Test]
-        public void Can_Identify_Excluded_Types()
+        [TestCase("Concrete")]
+        [TestCase("InnerConcrete")]
+        [TestCase("InnerInnerConcrete")]
+        public void Can_Identify_Excluded_Types(string typeName)
         {
             // 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));
-            }
+            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 typeDefinition in sourceAssembly.MainModule.Types.Where(x => x.Name == "Concrete"))
+            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(typeDefinition));
+                Assert.True(filter.ExcludeByAttribute(nestedType));
             }
         }
 

diff --git a/main/OpenCover.Test/Samples/Samples.cs b/main/OpenCover.Test/Samples/Samples.cs
@@ -2,12 +2,12 @@
 using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace OpenCover.Test.Samples
 {
     class ConstructorNotDeclaredClass
-    {
-
+    {        
     }
 
     class DeclaredConstructorClass
@@ -193,7 +193,32 @@ public override string Name
         [ExcludeMethodAttribute]
         public override void Method()
         {
-            throw new NotImplementedException();
+            throw new NotImplementedException();    
+        }
+
+        protected class InnerConcrete
+        {
+            public InnerConcrete()
+            {
+
+            }
+
+            public void Method()
+            {
+                var t = new Task(() =>
+                {
+                    Method();
+                    Method();
+                });
+            }
+
+            protected class InnerInnerConcrete
+            {
+                public InnerInnerConcrete()
+                {
+
+                }
+            }
         }
     }