public void Initialization_ReferenceNotTracked()
{
_assemblyDefinition1.MainModule.AssemblyReferences.Add(_assemblyDefinition2.Name);
AssemblyTracker tracker = new AssemblyTracker(new[] { _assemblyDefinition1 }, new TypeDefinitionCache());
Assert.That(tracker.GetAssemblies(), Is.EquivalentTo(new[] { _assemblyDefinition1 }));
}
static bool LoadSecurity(AssemblyTracker tracker, Type[] assembly_types)
{
bool useful = false;
foreach (Type t in assembly_types)
{
Type[] interfaces;
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorSecurity");
if (interfaces.Length > 0)
{
string name_override = null;
object[] tags = t.GetCustomAttributes(true);
foreach (object o in tags)
{
SecurityAttribute attr = o as SecurityAttribute;
if (attr != null)
{
name_override = attr.Name;
break;
}
}
useful = true;
TypeName type;
core_common.security_modules.Add(type = new TypeName(t));
if (name_override != null)
{
type.Name = name_override;
}
}
}
return(useful);
}
public void GetReverseReferences()
{
_assemblyDefinition1.MainModule.AssemblyReferences.Add(_assemblyDefinition2.Name);
AssemblyTracker tracker = new AssemblyTracker(new[] { _assemblyDefinition1, _assemblyDefinition2 }, new TypeDefinitionCache());
var reverseReferences = tracker.GetReverseReferences(_assemblyDefinition2);
Assert.That(reverseReferences, Is.EquivalentTo(new [] { _assemblyDefinition1 }));
}
public void MarkModified()
{
AssemblyTracker tracker = new AssemblyTracker(new[] { _assemblyDefinition1, _assemblyDefinition2 }, new TypeDefinitionCache());
tracker.MarkModified(_assemblyDefinition1);
Assert.That(tracker.IsModified(_assemblyDefinition1), Is.True);
Assert.That(tracker.IsModified(_assemblyDefinition2), Is.False);
}
public void GetModifiedAssemblies()
{
AssemblyTracker tracker = new AssemblyTracker(new[] { _assemblyDefinition1, _assemblyDefinition2 }, new TypeDefinitionCache());
tracker.MarkModified(_assemblyDefinition1);
var result = tracker.GetModifiedAssemblies();
Assert.That(result, Is.EquivalentTo(new[] { _assemblyDefinition1 }));
}
public void GetAssemblyByReference()
{
var name = AssemblyNameReferenceObjectMother.CreateAssemblyNameReference("TestCase1");
AssemblyDefinition assembly = AssemblyDefinitionObjectMother.CreateAssemblyDefinition("TestCase1");
AssemblyDefinition assembly2 = AssemblyDefinitionObjectMother.CreateAssemblyDefinition("TestCase2");
AssemblyTracker tracker = new AssemblyTracker(new[] { assembly, assembly2 }, new TypeDefinitionCache());
var result = tracker.GetAssembliesByReference(name);
Assert.That(result, Is.EqualTo(new [] { assembly }));
}
public void GetAssemblyByReference_NoMatchFound()
{
var name = AssemblyNameReferenceObjectMother.CreateAssemblyNameReferenceWithCulture("TestCase1", "de");
AssemblyDefinition assembly = AssemblyDefinitionObjectMother.CreateAssemblyDefinition("TestCase1");
AssemblyDefinition assembly2 = AssemblyDefinitionObjectMother.CreateAssemblyDefinition("TestCase2");
AssemblyTracker tracker = new AssemblyTracker(new[] { assembly, assembly2 }, new TypeDefinitionCache());
var result = tracker.GetAssembliesByReference(name);
Assert.That(result, Is.Empty);
}
private IAssemblyTracker CreateTracker(params AssemblyDefinition[] modifiedAssemblies)
{
// Should AssemblyTracker get external dependencies (or become otherwise more complex), consider using a stub instead of the real tracker.
var tracker = new AssemblyTracker(new[] { _assemblyDefinition1, _assemblyDefinition2 }, new TypeDefinitionCache());
foreach (var modifiedAssembly in modifiedAssemblies)
{
tracker.MarkModified(modifiedAssembly);
}
return(tracker);
}
public void GetReverseReferences_MultiModuleAssembly()
{
ModuleDefinition module = ModuleDefinition.CreateModule("Module1", ModuleKind.NetModule);
module.AssemblyReferences.Add(_assemblyDefinition2.Name);
_assemblyDefinition1.Modules.Add(module);
AssemblyTracker tracker = new AssemblyTracker(new[] { _assemblyDefinition1, _assemblyDefinition2 }, new TypeDefinitionCache());
var reverseReferences = tracker.GetReverseReferences(_assemblyDefinition2);
Assert.That(reverseReferences, Is.EquivalentTo(new[] { _assemblyDefinition1 }));
}
static bool InvokeDirector(AssemblyTracker tracker, Type[] assembly_types)
{
bool useful = false;
foreach (Type t in assembly_types)
{
Type[] interfaces;
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorDirectionShow");
if (interfaces.Length > 0)
{
useful = true;
object o = Activator.CreateInstance(t);
core_common.directors.Add(o as IReflectorDirectionShow);
}
}
return(useful);
}
static bool LoadDropAcceptors(AssemblyTracker tracker, Type[] assembly_types)
{
bool useful = false;
foreach (Type t in assembly_types)
{
Type[] interfaces;
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorDropFileTarget");
if (interfaces.Length > 0)
{
object o = null;
// for all created and tracked objects, see if it implements
// this drop acceptor interface.
foreach (AssemblyObject ao in tracker.objects)
{
if (ao.t == t)
{
o = ao.o;
useful = true;
break;
}
}
}
}
foreach (Type t in assembly_types)
{
Type[] interfaces;
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorPluginDropFileTarget");
if (interfaces.Length > 0)
{
ConstructorInfo ci = t.GetConstructor(System.Type.EmptyTypes);
if (ci != null)
{
object o = Activator.CreateInstance(t);
//tracker.objects.Add( new AssemblyObject( t, o ) );
useful = true;
core_common.drop_acceptors.Add(o as IReflectorPluginDropFileTarget);
}
}
}
return(useful);
}
public void IsModified_NotTracked()
{
AssemblyTracker tracker = new AssemblyTracker(new[] { _assemblyDefinition1 }, new TypeDefinitionCache());
Assert.Throws <ArgumentException> (() => tracker.IsModified(_assemblyDefinition2));
}
// plugins - these were objects that were instantiated during their load.
// should probably have an unload for these also... (might just spark their startup class
// which can cause persistant static classes, and destroy it after load... )
public static bool LoadAssembly(string name
, out System.Windows.Forms.ToolStripMenuItem outitems
, EventHandler click_handler
, EventHandler persistant_plugin_handler
, AssemblyTracker tracker)
{
Assembly a;
try
{
a = LoadAssembly(name);
if (a == null)
{
outitems = null;
return(false);
}
if (tracker == null)
{
tracker = new AssemblyTracker(a);
}
else
{
tracker.assembly = a;
}
foreach (AssemblyTracker assembly in core_common.assemblies)
{
if (String.Compare(assembly.ToString(), tracker.ToString()) == 0)
{
// uhmm really trusting garbabe collector here...
tracker.assembly = null;
a = null;
outitems = null;
return(false);
}
}
Type[] assembly_types = null;
try
{
assembly_types = a.GetTypes();
}
catch (Exception ex)
{
Log.log("Failed to get types from assembly. "
+ name + " : "
+ ex.Message);
a = null;
tracker.assembly = null;
core_common.assemblies.Remove(tracker);
outitems = null;
return(false);
}
List <ToolStripItem> items = null;
/*
* the following 3 are actually filled with TypeMenuItem...
* but for ease of use we store them as a list of their base class.
*/
List <ToolStripItem> button_items = new List <ToolStripItem>();
List <ToolStripItem> control_items = new List <ToolStripItem>();
List <ToolStripItem> canvas_items = new List <ToolStripItem>();
bool useful = false;
// search for any objects which implement IReflectorPlugin method Preload()
if (InvokePreload(tracker, assembly_types, persistant_plugin_handler))
{
useful = true;
}
if (LoadVariables(tracker, assembly_types))
{
useful = true;
}
if (LoadDropAcceptors(tracker, assembly_types))
{
useful = true;
}
if (LoadSecurity(tracker, assembly_types))
{
useful = true;
}
if (InvokeDirector(tracker, assembly_types))
{
useful = true;
}
foreach (Type current_type in assembly_types)
{
// 1) a thing must have a constructor of some type
// empty conctructor, takes a Canvas or a Control or a PSI_Button
if ((current_type.GetConstructor(System.Type.EmptyTypes) == null) &&
(current_type.GetConstructor(new Type[1] {
typeof(Canvas)
}) == null) &&
(current_type.GetConstructor(new Type[1] {
typeof(Control)
}) == null) &&
(current_type.GetConstructor(new Type[1] {
typeof(PSI_Button)
}) == null))
{
continue;
}
if (IsAWidget(current_type))
{
useful = true;
}
if (IsAButton(current_type))
{
//TypeMenuItem item;
useful = true;
core_common.buttons.Add(current_type);
String name_override = null;
object[] tags = current_type.GetCustomAttributes(true);
bool ignore_button = false;
foreach (object o in tags)
{
ButtonAttribute attr = o as ButtonAttribute;
if (attr != null)
{
if (attr.hidden)
{
ignore_button = true;
}
name_override = attr.Name;
break;
}
}
if (!ignore_button)
{
AddMenuItem(button_items, current_type, name_override, typeof(IReflectorButton), click_handler);
}
}
if (IsACanvas(current_type))
{
TypeMenuItem item;
useful = true;
canvas_items.Add(item = new TypeMenuItem(current_type, typeof(IReflectorCanvas)));
item.Click += click_handler;
}
if (IsAControl(current_type))
{
String name_override = null;
object[] tags = current_type.GetCustomAttributes(true);
foreach (object o in tags)
{
ControlAttribute attr = o as ControlAttribute;
if (attr != null)
{
name_override = attr.Name;
}
}
if (name_override != null)
{
AddMenuItem(control_items, current_type, name_override, current_type, click_handler);
useful = true;
}
else if (current_type.IsSubclassOf(typeof(XListbox)))
{
AddMenuItem(control_items, current_type, null, current_type, click_handler);
useful = true;
}
else if (current_type.IsSubclassOf(typeof(XComboBox)))
{
AddMenuItem(control_items, current_type, null, current_type, click_handler);
useful = true;
}
//useful = true;
}
if (IsCreatable(current_type))
{
useful = true;
String name_override = null;
object[] tags = current_type.GetCustomAttributes(true);
foreach (object o in tags)
{
ControlAttribute attr = o as ControlAttribute;
if (attr != null)
{
name_override = attr.Name;
}
}
AddMenuItem(control_items, current_type, name_override, typeof(IReflectorCreate), click_handler);
}
}
foreach (IReflectorPluginModule module in core_common.plugin_module_acceptors)
{
if (module.AssemblyUseful(tracker.assembly))
{
useful = true;
}
}
if (useful)
{
core_common.assemblies.Add(tracker);
ToolStripDropDown dropDown;
//outitems = items.ToArray();
int subs = 0;
if (button_items.Count > 0)
{
items = button_items;
subs++;
}
if (control_items.Count > 0)
{
items = control_items;
subs++;
}
if (canvas_items.Count > 0)
{
items = canvas_items;
subs++;
}
if (subs > 1)
{
ToolStripMenuItem menu_item;
items = new List <ToolStripItem>();
if (button_items.Count > 0)
{
dropDown = new ToolStripDropDown();
InsertMenuItems(dropDown, button_items);
menu_item = new ToolStripMenuItem("Buttons");
//menu_item.Text = ;
menu_item.DropDown = dropDown;
//menu_item.DropDownDirection = ToolStripDropDownDirection.Default;
//menu_item.ShowDropDownArrow = true;
items.Add(menu_item);
}
if (control_items.Count > 0)
{
dropDown = new ToolStripDropDown();
InsertMenuItems(dropDown, control_items);
menu_item = new ToolStripMenuItem("Controls");
// menu_item.Text = ;
menu_item.DropDown = dropDown;
//menu_item.DropDownDirection = ToolStripDropDownDirection.Default;
//menu_item.ShowDropDownArrow = true;
items.Add(menu_item);
}
if (canvas_items.Count > 0)
{
dropDown = new ToolStripDropDown();
InsertMenuItems(dropDown, canvas_items);
menu_item = new ToolStripMenuItem();
menu_item.Text = "Page Layout";
menu_item.DropDown = dropDown;
menu_item.DropDownDirection = ToolStripDropDownDirection.Default;
//menu_item.ShowDropDownArrow = true;
items.Add(menu_item);
}
}
if (subs > 0)
{
dropDown = new ToolStripDropDown();
foreach (ToolStripItem tsi in items)
{
InsertMenuItem(dropDown, tsi);
}
ToolStripMenuItem itemx = new ToolStripMenuItem();
itemx.Text = osalot.StripExeFromName(a.ManifestModule.Name);
itemx.DropDown = dropDown;
itemx.DropDownDirection = ToolStripDropDownDirection.Default;
//itemx.ShowDropDownArrow = true;
outitems = itemx; // returning this one menu entry....
return(true);
}
outitems = null;
return(useful); // just cause there's no menu options (IReflectorSecurity) doesn't mean we didn't use it...
}
else
{
// help garbage collection...
tracker.assembly = null;
tracker = null;
a = null;
}
}
catch (FileNotFoundException fnf)
{
Log.log("Could not load Assembly: \"" + name + "\" : " + fnf.Message);
}
catch (TypeLoadException)
{
Log.log("Could not load Type: \"\"\nfrom assembly: \"" + name + "\"");
}
outitems = null;
return(false);
}
public void GetReverseReferences_NotTracked()
{
AssemblyTracker tracker = new AssemblyTracker(new AssemblyDefinition[0], new TypeDefinitionCache());
Assert.Throws <ArgumentException> (() => tracker.GetReverseReferences(_assemblyDefinition1));
}
static bool LoadVariables(AssemblyTracker tracker, Type[] assembly_types)
{
bool useful = false;
foreach (Type t in assembly_types)
{
Type[] interfaces;
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorVariable");
if (interfaces.Length > 0)
{
object o = null;
foreach (AssemblyObject ao in tracker.objects)
{
if (ao.t == t)
{
o = ao.o;
break;
}
}
if (o == null)
{
ConstructorInfo ci = t.GetConstructor(System.Type.EmptyTypes);
if (ci != null)
{
o = Activator.CreateInstance(t);
tracker.objects.Add(new AssemblyObject(t, o));
useful = true;
variables.Variables.AddVariableInterface((o as IReflectorVariable).Name
, o as IReflectorVariable);
}
}
}
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorVariableArray");
if (interfaces.Length > 0)
{
object o = null;
foreach (AssemblyObject ao in tracker.objects)
{
if (ao.t == t)
{
o = ao.o;
break;
}
}
if (o == null)
{
ConstructorInfo ci = t.GetConstructor(System.Type.EmptyTypes);
if (ci != null)
{
o = Activator.CreateInstance(t);
tracker.objects.Add(new AssemblyObject(t, o));
useful = true;
variables.Variables.AddVariableInterface((o as IReflectorVariableArray).Name
, o as IReflectorVariableArray);
}
}
}
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorVariableNamedArray");
if (interfaces.Length > 0)
{
object o = null;
foreach (AssemblyObject ao in tracker.objects)
{
if (ao.t == t)
{
o = ao.o;
break;
}
}
if (o == null)
{
ConstructorInfo ci = t.GetConstructor(System.Type.EmptyTypes);
if (ci != null)
{
o = Activator.CreateInstance(t);
tracker.objects.Add(new AssemblyObject(t, o));
useful = true;
variables.Variables.AddVariableInterface((o as IReflectorVariableNamedArray).Name
, o as IReflectorVariableNamedArray);
}
}
}
}
return(useful);
}
static bool InvokePreload(AssemblyTracker tracker, Type[] assembly_types, EventHandler handler)
{
int previous_assemblies = tracker.objects.Count;
int previous = core_common.persistant_plugins.Count;
foreach (Type t in assembly_types)
{
Type[] interfaces;
interfaces = t.FindInterfaces(MyInterfaceFilter, "IReflectorPlugin");
if (interfaces.Length > 0)
{
AssemblyObject ao;
object o = Activator.CreateInstance(t);
tracker.objects.Add(ao = new AssemblyObject(t, o));
try
{
IReflectorPlugin plugin = o as IReflectorPlugin;
if (plugin != null)
{
plugin.Preload();
ao.plugin = true;
}
}
catch (Exception ex)
{
Log.log("Invoke preload threw exception... " + t.ToString() + ":" + ex.Message);
}
IReflectorPersistance persis = o as IReflectorPersistance;
if (persis != null) // it's a plugin, and has properties
{
object[] tags = t.GetCustomAttributes(true);
String name = null;
foreach (object tag in tags)
{
PluginAttribute attr = tag as PluginAttribute;
if (attr != null)
{
name = attr.Name;
}
}
if (name == null)
{
name = o.ToString();
}
core_common.persistant_plugins.Add(o);
TypeMenuItem tmi = new TypeMenuItem(o, name);
InsertMenuItem(core_common.other_drop.DropDown, tmi);
tmi.Click += handler;
}
IReflectorPluginModule module_acceptor = o as IReflectorPluginModule;
if (module_acceptor != null) // it's a plugin, and has properties
{
core_common.plugin_module_acceptors.Add(module_acceptor);
}
}
}
if (core_common.persistant_plugins.Count > previous ||
tracker.objects.Count > previous_assemblies)
{
return(true);
}
return(false);
}
public void Initialization()
{
AssemblyTracker tracker = new AssemblyTracker(new [] { _assemblyDefinition1, _assemblyDefinition2 }, new TypeDefinitionCache());
Assert.That(tracker.GetAssemblies(), Is.EquivalentTo(new[] { _assemblyDefinition1, _assemblyDefinition2 }));
}
