private void Ex_plugins_Load(object sender, EventArgs e)
{
manager = new PluginsManager();
plugin1 = new Plugin1(manager.Caller);
manager.PluginEventReceived += Manager_PluginEventReceived;
manager.RegisterPlugin(plugin1);
}
public void Should_prepend_type_plugin_before_another(
[Values(true, false)] bool @default,
[Values(true, false)] bool orPrepend)
{
var instance1 = new Plugin1();
_pluginsDsl.Append(instance1);
_pluginsDsl.Append <Plugin2>();
var dsl = _pluginsDsl.Prepend <Plugin3>(@default);
if (orPrepend)
{
dsl.BeforeOrPrepend <Plugin2>();
}
else
{
dsl.BeforeOrAppend <Plugin2>();
}
_plugins.Count().ShouldEqual(3);
_plugins.First().Instance.ShouldEqual(instance1);
var prepended = _plugins.Second();
prepended.Type.ShouldEqual(typeof(Plugin3));
prepended.Singleton.ShouldBeTrue();
_plugins.Third().Type.ShouldEqual(typeof(Plugin2));
_plugins.IsDefault(Plugin <IPluginType> .Create <Plugin3>())
.ShouldEqual(@default);
}
public void Should_not_return_plugins_for_instances_that_dont_map()
{
var instance1 = new Plugin1();
var instance2 = new Plugin1();
var instance3 = new Plugin1();
var plugin2 = Plugin <IPluginType> .Create(instance2);
var plugin3 = Plugin <IPluginType> .Create(instance3);
_plugins.Append(plugin2);
_plugins.Append(plugin3);
var result = _plugins.PluginsFor(new[] { instance3, instance1, instance2 }).ToList();
result.Count.ShouldEqual(2);
var plugin = result.First();
plugin.Instance.ShouldEqual(instance2);
plugin.Plugin.ShouldEqual(plugin2);
plugin = result.Second();
plugin.Instance.ShouldEqual(instance3);
plugin.Plugin.ShouldEqual(plugin3);
}
public void Should_prepend_type_plugin_if_it_cannot_prepend_before_another(
[Values(true, false)] bool @default,
[Values(true, false)] bool when)
{
var instance1 = new Plugin1();
_pluginsDsl.Append(instance1);
RunInScope(when, (dsl, p) => dsl
.Prepend <Plugin2>(p, @default)
.BeforeOrPrepend <Plugin3>());
_plugins.Count().ShouldEqual(2);
var prepended = _plugins.First();
prepended.Type.ShouldEqual(typeof(Plugin2));
prepended.Singleton.ShouldBeTrue();
prepended.AppliesTo.ShouldEqual(_predicate);
_plugins.Second().Instance.ShouldEqual(instance1);
_plugins.IsDefault(ConditionalPlugin <IPluginType, Context>
.Create <Plugin2>(x => false))
.ShouldEqual(@default);
}
public static void Shutdown()
{
if (_instance == null)
{
return;
}
DynamicPluginsManager.Unregister(_instance._id);
_instance = null;
}
public void Should_return_index_of_first_plugin_instance_if_instance_exists()
{
var instance = new Plugin1();
_plugins.Append(Plugin <IPluginType> .Create <Plugin1>());
_plugins.Append(Plugin <IPluginType> .Create(new Plugin1()));
_plugins.Append(Plugin <IPluginType> .Create(instance));
_plugins.Append(Plugin <IPluginType> .Create(instance));
_plugins.IndexOf(instance).ShouldEqual(2);
}
public void Should_return_first_instance_plugin_by_instance_if_exists()
{
var instance = new Plugin1();
var plugin = Plugin <IPluginType> .Create(instance);
_plugins.Append(Plugin <IPluginType> .Create <Plugin1>());
_plugins.Append(Plugin <IPluginType> .Create(new Plugin1()));
_plugins.Append(plugin);
_plugins.Append(Plugin <IPluginType> .Create(instance));
var result = _plugins.InstanceOrTypePluginFor(instance);
result.ShouldEqual(plugin);
}
public void Should_generate_instance_hash_code()
{
var instance = new Plugin1();
var plugin1a = Plugin <IPluginType> .Create(instance);
var plugin1b = Plugin <IPluginType> .Create(instance);
var plugin2 = Plugin <IPluginType> .Create(new Plugin1());
plugin1a.GetHashCode().ShouldNotEqual(instance.GetHashCode());
plugin1a.GetHashCode().ShouldNotEqual(instance.GetType().GetHashCode());
plugin1a.GetHashCode().ShouldEqual(plugin1b.GetHashCode());
plugin1a.GetHashCode().ShouldNotEqual(plugin2.GetHashCode());
}
public void Should_clone_instance_plugin()
{
var instance = new Plugin1();
var plugin = Plugin <IPluginType> .Create(instance, true);
var clone = plugin.Clone();
(clone == plugin).ShouldBeFalse();
clone.ShouldEqual(plugin);
clone.Singleton.ShouldEqual(plugin.Singleton);
clone.HasInstance.ShouldEqual(plugin.HasInstance);
clone.Type.ShouldEqual(plugin.Type);
clone.Instance.ShouldEqual(plugin.Instance);
clone.Dispose.ShouldEqual(plugin.Dispose);
}
public void Should_remove_instance_plugin_by_instance()
{
var keep1 = Plugin <IPluginType> .Create(new Plugin1());
var keep2 = Plugin <IPluginType> .Create <Plugin1>();
var instance = new Plugin1();
var remove = Plugin <IPluginType> .Create(instance);
_plugins.Append(keep1);
_plugins.Append(remove);
_plugins.Append(keep2);
_plugins.RemoveInstancePlugin(instance)
.ShouldOnlyContain(keep1, keep2);
}
public void Should_get_the_default_instance()
{
var plugin1 = new Plugin1();
var plugin2 = new Plugin2();
var plugin3 = new Plugin3();
var plugin4 = new Plugin4();
var instances = new IPluginType[] { plugin1, plugin2, plugin3, plugin4 };
var plugins = new ConditionalPlugins <IPluginType, Context>(false)
.Configure(x => x
.Append <Plugin1>()
.Append <Plugin2>(@default: true)
.Append <Plugin3>(@default: true)
.Append <Plugin4>());
plugins.GetDefaultInstance(instances).ShouldEqual(plugin3);
}
public void Should_register_plugins_with_registry()
{
var instance = new Plugin1();
var registry = new Registry(new TypeCache());
var plugin1 = Plugin <IPluginType> .Create(instance, true);
var plugin2 = Plugin <IPluginType> .Create <Plugin2>(true);
var plugins = new Plugins <IPluginType>(true);
plugins.Append(plugin1).Append(plugin2);
registry.RegisterPlugins(plugins);
registry.Count().ShouldEqual(2);
Should_be_plugin_instance(registry.First(), instance);
Should_be_plugin_type <Plugin2>(registry.Second());
}
public void Should_register_conditional_plugins_in_container()
{
var instance = new Plugin1();
var container = new Container();
var plugin1 = ConditionalPlugin <IPluginType, Context> .Create(instance, x => false, true);
var plugin2 = ConditionalPlugin <IPluginType, Context> .Create <Plugin2>(x => false, true);
var plugins = new ConditionalPlugins <IPluginType, Context>(true);
plugins.Append(plugin1).Append(plugin2);
container.RegisterPlugins(plugins);
var instances = container.GetInstances <IPluginType>();
instances.Count().ShouldEqual(2);
instances.ShouldContain(instance);
}
public void Should_prepend_type_plugin(
[Values(true, false)] bool @default)
{
var instance1 = new Plugin1();
_pluginsDsl.Append(instance1);
_pluginsDsl.Prepend <Plugin2>(@default);
_plugins.Count().ShouldEqual(2);
var prepended = _plugins.First();
prepended.Type.ShouldEqual(typeof(Plugin2));
prepended.Singleton.ShouldBeTrue();
_plugins.Second().Instance.ShouldEqual(instance1);
_plugins.IsDefault(Plugin <IPluginType> .Create <Plugin2>())
.ShouldEqual(@default);
}
public void Should_append_type_plugin_if_it_cannot_append_after_another(
[Values(true, false)] bool @default)
{
var instance1 = new Plugin1();
_pluginsDsl.Append(instance1);
_pluginsDsl.Append <Plugin2>(@default).AfterOrAppend <Plugin3>();
_plugins.Count().ShouldEqual(2);
_plugins.First().Instance.ShouldEqual(instance1);
var appended = _plugins.Second();
appended.Type.ShouldEqual(typeof(Plugin2));
appended.Singleton.ShouldBeTrue();
_plugins.IsDefault(Plugin <IPluginType> .Create <Plugin2>())
.ShouldEqual(@default);
}
public void Should_append_type_plugin_after_another(
[Values(true, false)] bool @default,
[Values(true, false)] bool orAppend,
[Values(true, false)] bool when)
{
var instance1 = new Plugin1();
_pluginsDsl.Append(instance1);
_pluginsDsl.Append <Plugin2>();
RunInScope(when, (dsl, p) =>
{
var appendDsl = dsl.Append <Plugin3>(_predicate, @default);
if (orAppend)
{
appendDsl.AfterOrAppend <Plugin1>();
}
else
{
appendDsl.AfterOrPrepend <Plugin1>();
}
});
_plugins.Count().ShouldEqual(3);
_plugins.First().Type.ShouldEqual(typeof(Plugin1));
var appended = _plugins.Second();
appended.Type.ShouldEqual(typeof(Plugin3));
appended.Singleton.ShouldBeTrue();
appended.AppliesTo.ShouldEqual(_predicate);
_plugins.Third().Type.ShouldEqual(typeof(Plugin2));
_plugins.IsDefault(ConditionalPlugin <IPluginType, Context>
.Create <Plugin3>(x => false))
.ShouldEqual(@default);
}
public void Should_return_plugins_for_instances(
[Values(true, false)] bool @default)
{
var instance1 = new Plugin1();
var instance2 = new Plugin1();
var instance3 = new Plugin1();
var plugin2 = Plugin <IPluginType> .Create(instance2);
var plugin3 = Plugin <IPluginType> .Create(instance3);
var typePlugin = Plugin <IPluginType> .Create <Plugin1>();
_plugins.Append(Plugin <IPluginType> .Create(new Plugin1()));
_plugins.Append(plugin2, @default);
_plugins.Append(plugin3);
_plugins.Append(typePlugin);
var result = _plugins.PluginsFor(new [] { instance3, instance1, instance2 }).ToList();
result.Count.ShouldEqual(3);
var plugin = result.First();
plugin.Instance.ShouldEqual(instance2);
plugin.IsDefault.ShouldEqual(@default);
plugin.Plugin.ShouldEqual(plugin2);
plugin = result.Second();
plugin.Instance.ShouldEqual(instance3);
plugin.IsDefault.ShouldBeFalse();
plugin.Plugin.ShouldEqual(plugin3);
plugin = result.Third();
plugin.Instance.ShouldEqual(instance1);
plugin.IsDefault.ShouldBeFalse();
plugin.Plugin.ShouldEqual(typePlugin);
}
void OnApplicationQuit()
{
Plugin1.Shutdown();
}
