- ignoring assembly loading errors

Author: kkozmic

ConventionTests/ConventionTests.NUnit.cs

@@ -144,7 +144,8 @@ protected virtual Assembly[] GetAssembliesToScan(ConventionData data)
 			var companyName = assembly.FullName.Substring(0, assembly.FullName.IndexOf('.'));
 			var assemblyNames = assembly.GetReferencedAssemblies();
 			var applicationAssemblies = Array.FindAll(assemblyNames, n => n.FullName.StartsWith(companyName));
-			return Array.ConvertAll(applicationAssemblies, Assembly.Load);
+		    var assemblies = Array.ConvertAll(applicationAssemblies, n => n.TryLoadAssembly());
+            return Array.FindAll(assemblies, a => a != null);
 		}
 
 		/// <summary>
@@ -156,22 +157,10 @@ protected virtual Assembly[] GetAssembliesToScan(ConventionData data)
 		protected virtual Type[] GetTypesToTest(ConventionData data)
 		{
 			return
-                GetAssembliesToScan(data).SelectMany(GetTypesSafely).Where(data.Types.Invoke).OrderBy(t => t.FullName)
+                GetAssembliesToScan(data).SelectMany(a => a.SafeGetTypes()).Where(data.Types.Invoke).OrderBy(t => t.FullName)
                     .ToArray();
         }
-
-        private static IEnumerable<Type> GetTypesSafely(Assembly assembly)
-        {
-            try
-            {
-                return assembly.GetTypes();
-            }
-            catch (ReflectionTypeLoadException ex)
-            {
-                return ex.Types.Where(x => x != null);
-            }
-        }
-    }
+	}
 
 	public abstract class WindsorConventionTest<TDiagnostic> : WindsorConventionTest<TDiagnostic, IHandler>
 		where TDiagnostic : class, IDiagnostic<IEnumerable<IHandler>>, IDiagnostic<object>

ConventionTests/ConventionTests.csproj.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Conventions/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

ConventionTests/Conventions/__Run.cs

@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using ApprovalTests.Reporters;
@@ -8,53 +9,92 @@
 
 namespace ConventionTests
 {
-	[TestFixture]
-	public class ConventionTestsRunner
-	{
-		[TestFixtureSetUp]
-		public static void GlobalSetUp()
-		{
-		}
-
-		public TestCaseData[] Conventions
-		{
-			get
-			{
-				var types = GetConventionTypes();
-				var conventionTests = Array.ConvertAll(types, BuildTestData);
-				return conventionTests;
-			}
-		}
-
-		private TestCaseData BuildTestData(Type t)
-		{
-			var convention = CreateConvention(t);
-			return new TestCaseData(convention).SetName(convention.Name);
-		}
-
-		private static IConventionTest CreateConvention(Type t)
-		{
-			return (IConventionTest) Activator.CreateInstance(t);
-		}
-
-		private static Type[] GetConventionTypes()
-		{
-			var types =
-				Assembly.GetExecutingAssembly().GetExportedTypes().Where(
-					IsConventionTest).ToArray();
-			return types;
-		}
-
-		private static bool IsConventionTest(Type type)
-		{
-			return type.IsClass && type.IsAbstract == false && typeof (IConventionTest).IsAssignableFrom(type);
-		}
-
-		[Test]
-		[TestCaseSource("Conventions")]
-		public void Run(IConventionTest test)
-		{
-			test.Execute();
-		}
-	}
+    [TestFixture]
+    public class ConventionTestsRunner
+    {
+        [TestFixtureSetUp]
+        public static void GlobalSetUp()
+        {
+        }
+
+        public TestCaseData[] Conventions
+        {
+            get
+            {
+                var types = GetConventionTypes();
+                var conventionTests = Array.ConvertAll(types, BuildTestData);
+                return conventionTests;
+            }
+        }
+
+        private TestCaseData BuildTestData(Type t)
+        {
+            var convention = CreateConvention(t);
+            return new TestCaseData(convention).SetName(convention.Name);
+        }
+
+        private static IConventionTest CreateConvention(Type t)
+        {
+            return (IConventionTest) Activator.CreateInstance(t);
+        }
+
+        private static Type[] GetConventionTypes()
+        {
+            var types =
+                Assembly.GetExecutingAssembly().GetExportedTypes().Where(
+                    IsConventionTest).ToArray();
+            return types;
+        }
+
+        private static bool IsConventionTest(Type type)
+        {
+            return type.IsClass && type.IsAbstract == false && typeof (IConventionTest).IsAssignableFrom(type);
+        }
+
+        [Test]
+        [TestCaseSource("Conventions")]
+        public void Run(IConventionTest test)
+        {
+            test.Execute();
+        }
+    }
+
+    public static class ReflectionExtensions
+    {
+        public static Assembly TryLoadAssembly(this AssemblyName name)
+        {
+            try
+            {
+                return Assembly.Load(name);
+            }
+            catch (FileNotFoundException)
+            {
+                return null;
+            }
+            catch (FileLoadException)
+            {
+                return null;
+            }
+            catch (BadImageFormatException)
+            {
+                return null;
+            }
+            catch (ReflectionTypeLoadException)
+            {
+                return null;
+            }
+        }
+
+        public static Type[] SafeGetTypes(this Assembly assembly)
+        {
+            try
+            {
+                return assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                return Array.FindAll(ex.Types, x => x != null);
+            }
+        }
+    }
 }