diff --git a/src/SenseNet.Tools.Tests/SenseNet.Tools.Tests.csproj b/src/SenseNet.Tools.Tests/SenseNet.Tools.Tests.csproj
index c16e14c..e680eff 100644
--- a/src/SenseNet.Tools.Tests/SenseNet.Tools.Tests.csproj
+++ b/src/SenseNet.Tools.Tests/SenseNet.Tools.Tests.csproj
@@ -65,6 +65,7 @@
     <Compile Include="SnTraceTestClass.cs" />
     <Compile Include="SnTraceTests.cs" />
     <Compile Include="SnLogTests.cs" />
+    <Compile Include="TypeResolverTests.cs" />
     <Compile Include="UtilityTests.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/SenseNet.Tools.Tests/TypeResolverTests.cs b/src/SenseNet.Tools.Tests/TypeResolverTests.cs
new file mode 100644
index 0000000..0732444
--- /dev/null
+++ b/src/SenseNet.Tools.Tests/TypeResolverTests.cs
@@ -0,0 +1,65 @@
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace SenseNet.Tools.Tests
+{
+    #region Test classes
+
+    internal interface ITestInterface
+    {
+    }
+
+    internal class BaseClass
+    {
+    }
+
+    internal class DerivedClass1 : BaseClass
+    {
+    }
+    internal class DerivedClass11 : DerivedClass1, ITestInterface
+    {
+    }
+    internal class IndependentClass1 : ITestInterface
+    {
+    }
+
+    #endregion
+
+    [TestClass]
+    public class TypeResolverTests
+    {
+        [TestMethod]
+        public void TypeResolver_GetType()
+        {
+            var t = TypeResolver.GetType("SenseNet.Tools.TypeResolver");
+            Assert.IsNotNull(t);
+        }
+
+        [TestMethod]
+        public void TypeResolver_GetTypesByBaseType()
+        {
+            var types = TypeResolver.GetTypesByBaseType(typeof(BaseClass));
+
+            Assert.AreEqual(2, types.Length);
+            Assert.IsTrue(types.Any(t => t.Name == "DerivedClass1"));
+            Assert.IsTrue(types.Any(t => t.Name == "DerivedClass11"));
+        }
+        [TestMethod]
+        public void TypeResolver_GetTypesByInterface()
+        {
+            var types = TypeResolver.GetTypesByInterface(typeof(ITestInterface));
+
+            Assert.AreEqual(2, types.Length);
+            Assert.IsTrue(types.Any(t => t.Name == "DerivedClass11"));
+            Assert.IsTrue(types.Any(t => t.Name == "IndependentClass1"));
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(TypeNotFoundException))]
+        public void TypeResolver_Error_GetType()
+        {
+            var t = TypeResolver.GetType("UnknownType");
+            Assert.IsNotNull(t);
+        }
+    }
+}
diff --git a/src/SenseNet.Tools/Tools/TypeResolver.cs b/src/SenseNet.Tools/Tools/TypeResolver.cs
index d91d9cf..a0f74d5 100644
--- a/src/SenseNet.Tools/Tools/TypeResolver.cs
+++ b/src/SenseNet.Tools/Tools/TypeResolver.cs
@@ -247,10 +247,18 @@ public static Type[] GetTypesByInterface(Type interfaceType)
                                 list.AddRange(asm.GetTypes().Where(type =>
                                     type.GetInterfaces().Any(interf => interf == interfaceType)));
                             }
-                            catch (Exception e)
+                            catch (ReflectionTypeLoadException e)
                             {
                                 if (!IgnorableException(e))
+                                {
+                                    LogTypeLoadException(e, asm.FullName);
                                     throw;
+                                }
+                            }
+                            catch (Exception e)
+                            {
+                                if (!IgnorableException(e))
+                                    throw TypeDiscoveryError(e, null, asm);
                             }
                         }
                         temp = list.ToArray();
@@ -300,17 +308,13 @@ public static Type[] GetTypesByBaseType(Type baseType)
                                     }
                                 }
                             }
-                            catch (ReflectionTypeLoadException rtle)
+                            catch (ReflectionTypeLoadException e)
                             {
-                                SnLog.WriteError(rtle.ToString(), properties: new Dictionary<string, object> { { "Assembly", asm.FullName } });
-
-                                // Logging each exception
-                                foreach (var exc in rtle.LoaderExceptions)
+                                if (!IgnorableException(e))
                                 {
-                                    SnLog.WriteError(exc);
+                                    LogTypeLoadException(e, asm.FullName);
+                                    throw;
                                 }
-
-                                throw;
                             }
                             catch (Exception e)
                             {
@@ -331,6 +335,15 @@ public static Type[] GetTypesByBaseType(Type baseType)
             return result;
         }
 
+        private static void LogTypeLoadException(ReflectionTypeLoadException rtle, string assemblyName = null)
+        {
+            SnLog.WriteError(rtle.ToString(), properties: new Dictionary<string, object> { { "Assembly", assemblyName ?? "unknown" } });
+
+            foreach (var exc in rtle.LoaderExceptions)
+            {
+                SnLog.WriteError(exc);
+            }
+        }
         private static bool IgnorableException(Exception e)
         {
             if (!Debugger.IsAttached)