public void when_non_existant_directory_on_disk()
{
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <IInterface>("C:\\Foo\\Bar.dll");
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public static IEnumerable <IWrapper> LoadDynamicWrapper(string assemblyPath)
{
lock (_loadDynamicWrapperLockObj)
{
if (!_dynamicLoadAssemblyStatus.TryGetValue(assemblyPath.ToLower(), out var wrappers))
{
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <IWrapper>(assemblyPath);
foreach (var ex in result.Exceptions)
{
Log.Warn($"An exception occurred while loading an extension from assembly {assemblyPath}: {ex}");
}
wrappers = result.Instances.ToArray();
_dynamicLoadAssemblyStatus[assemblyPath.ToLower()] = wrappers;
if (Log.IsFinestEnabled)
{
Log.Finest($"Dynamically loaded wrappers from assembly {assemblyPath}: {string.Join(", ", (IEnumerable<IWrapper>)wrappers)}");
}
}
return(wrappers);
}
}
public void when_null_assemblies()
{
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(null);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void when_invalid_path()
{
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <IInterface>("!@#$%");
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void when_type_load_exception()
{
var directory = MakeTempDirForTest();
Action <string> testMethod1 = directoryPath =>
{
var interfaceAssemblyPath = Path.Combine(directoryPath, "IDoSomething.dll");
var interfaceAssembly = GenerateAssembly(@"public interface IDoSomething : IInterface { }", interfaceAssemblyPath);
var concreteAssemblyPath = Path.Combine(directoryPath, "DoNothing.dll");
GenerateAssembly(@"public class DoNothing : IDoSomething { }", concreteAssemblyPath, additionalAssemblyReferences: new[] { interfaceAssembly });
};
AppDomainExtensions.IsolateMethodInAppDomain(testMethod1, directory.FullName);
Action <string> testMethod2 = directoryPath =>
{
// Add a method to IDoSomething so that our DoNothing class is no longer a valid implementation and will throw a TypeLoadException when loaded
var interfaceAssemblyPath = Path.Combine(directoryPath, "IDoSomething.dll");
GenerateAssembly(@"public interface IDoSomething : IInterface { void DoSomething(); }", interfaceAssemblyPath);
var files = Directory.GetFiles(directoryPath);
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <IInterface>(files);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(1, result.Exceptions.Count());
};
AppDomainExtensions.IsolateMethodInAppDomain(testMethod2, directory.FullName);
directory.Delete(true);
}
public void when_null_directory()
{
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <IInterface>((string)null);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void when_no_assemblies()
{
var assemblies = new Assembly[] {};
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(assemblies);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void when_null_type()
{
var types = new Type[] { null };
var result = TypeInstantiator.InstancesFromTypes <IInterface>(types);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void when_multiple_interfaces()
{
var assembly = GenerateAssembly(@"public class Foo : IInterface, IInterface2 {}");
var assemblies = new[] { assembly };
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(assemblies);
Assert.AreEqual(1, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void when_empty_assembly()
{
var assembly = GenerateAssembly(@"");
var assemblies = new[] { assembly };
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(assemblies);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void when_constructor_throws_an_exception()
{
var assembly = GenerateAssembly(@"public class Foo : IInterface { public Foo() { throw new System.Exception(); } }");
var assemblies = new[] { assembly };
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(assemblies);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(1, result.Exceptions.Count());
}
public void when_is_derived()
{
var assembly = GenerateAssembly(
@"public class Foo : IInterface {}
public class Bar : Foo {}");
var assemblies = new[] { assembly };
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(assemblies);
Assert.AreEqual(2, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
public void ShouldNotLoadPrivateNestedClass()
{
var assemblies = new[]
{
GenerateAssembly(@"public class Foo : IInterface {}"),
GenerateAssembly(@"public class Foo { private class Bar : IInterface {} }"),
};
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(assemblies);
Assert.AreEqual(1, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
private void LoadMenuItems()
{
for (var i = 0; i < menuItemCount; i++)
{
actionButtons[i].Visible = false;
actionButtons[i].Text = string.Empty;
if (actionButtons[i] is ImageButton)
{
if (((ImageButton)actionButtons[i]).Image != null)
{
((ImageButton)actionButtons[i]).Image.Dispose();
}
}
}
if (list.Count < menuItemCount)
{
for (var i = 0; i < list.Count; i++)
{
actionButtons[i].Visible = true;
actionButtons[i].Text = list[i].Text;
SetImage(i, i);
if (!string.IsNullOrEmpty(list[i].Action))
{
actionButtons[i].Tag = TypeInstantiator <IAction> .LoadType(list[i].Action);
}
}
}
else
{
for (var i = currentPosition; i < currentPosition + menuItemCount && i < list.Count; i++)
{
actionButtons[i - currentPosition].Visible = true;
actionButtons[i - currentPosition].Text = list[i].Text;
SetImage(i - currentPosition, i);
if (!string.IsNullOrEmpty(list[i].Action))
{
actionButtons[i - currentPosition].Tag = TypeInstantiator <IAction> .LoadType(list[i].Action);
}
}
}
if (list.Count > menuItemCount)
{
navButton.Visible = true;
}
}
public void when_nested_class()
{
var assemblies = new[]
{
GenerateAssembly(@"public class Foo : IInterface {}"),
GenerateAssembly(@"public class Foo { public class Bar : IInterface {} }"),
};
var result = TypeInstantiator.ExportedInstancesFromAssemblies <IInterface>(assemblies);
Assert.AreEqual(2, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
}
/// <summary>
/// Automatically inspect assemblies in the install path and load/instantiate all items of type T.
/// This method will exclude NotAutoReflected assemblies. These assemblies are only loaded on-demand so as
/// to avoid TypeLoad exceptions from missing types.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
private static IEnumerable <T> AutoLoadExtensions <T>()
{
Log.Info($"Loading extensions of type {typeof(T)} from folder: {_installPathExtensionsDirectory}");
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <T>(_autoReflectedAssemblies);
foreach (var ex in result.Exceptions)
{
Log.Warn($"An exception occurred while loading an extension: {ex}");
}
return(result.Instances);
}
public void when_invalid_file_on_disk()
{
var directory = MakeTempDirForTest();
Action <string> testMethod = directoryPath =>
{
var filePath1 = Path.Combine(directoryPath, "foo.dll");
File.CreateText(filePath1);
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <IInterface>(filePath1);
Assert.AreEqual(0, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
};
AppDomainExtensions.IsolateMethodInAppDomain(testMethod, directory.FullName);
directory.Delete(true);
}
static Framework()
{
//CultureInfo = CultureInfo.CurrentCulture;
CultureInfo = null;
ConfigurationManager = new ConfigurationManagerAdapter();
//ConfigurationManager = new LuxConfigurationManager(new ConfigurationManagerAdapter());
ConfigManager = new XmlConfigManager();
TypeInstantiator = new TypeInstantiator();
Asserter = new EmptyAsserter();
LogFactory = new NullObjectLogFactory();
#if DEBUG
LogFactory = new DebugLogFactory();
#endif
}
public void when_finds_files_on_disk()
{
var directory = MakeTempDirForTest();
Action <string> testMethod = directoryPath =>
{
var filePath1 = Path.Combine(directoryPath, "foo.dll");
var filePath2 = Path.Combine(directoryPath, "bar.dll");
GenerateAssembly(@"public class Foo : IInterface {}", filePath1);
GenerateAssembly(@"public class Bar : IInterface {}", filePath2);
var result = TypeInstantiator.ExportedInstancesFromAssemblyPaths <IInterface>(filePath1, filePath2);
Assert.AreEqual(2, result.Instances.Count());
Assert.AreEqual(0, result.Exceptions.Count());
};
AppDomainExtensions.IsolateMethodInAppDomain(testMethod, directory.FullName);
directory.Delete(true);
}
public void AddTypeInstantiator <T>(TypeInstantiator typeInstantiator)
{
_instantiators.Add(typeof(T), typeInstantiator);
}
public static void AddTypeSubstitution <T>(TypeInstantiator typeInstantiator)
{
TypeSubstitution.Add(typeof(T), typeInstantiator);
}
