public void BoxedEnumReference()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("CustomAttributes").MainModule;
var bzzz = module.GetType("Bzzz");
var attribute = GetAttribute(bzzz, "Foo");
Assert.IsNotNull(attribute);
// [Foo (new object [] { Bingo.Fuel, Bingo.Binga }, null, Pan = System.Security.AccessControl.AceFlags.NoPropagateInherit)]
Assert.AreEqual(2, attribute.ConstructorArguments.Count);
var argument = attribute.ConstructorArguments [0];
AssertCustomAttributeArgument("(Object:(Object[]:{(Object:(ValueType:2)), (Object:(ValueType:4))}))", argument);
argument = attribute.ConstructorArguments [1];
AssertCustomAttributeArgument("(Object:(String:null))", argument);
argument = attribute.Fields.Where(a => a.Name == "Pan").First().Argument;
AssertCustomAttributeArgument("(Object:(Class:4))", argument);
}
public void FieldsAndProperties()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("CustomAttributes").MainModule;
var angola = module.GetType("Angola");
var attribute = GetAttribute(angola, "Foo");
Assert.IsNotNull(attribute);
Assert.AreEqual(2, attribute.Fields.Count);
var argument = attribute.Fields.Where(a => a.Name == "Pan").First();
AssertCustomAttributeArgument("(Object:(Object[]:{(Object:(Int32:1)), (Object:(String:\"2\")), (Object:(Char:'3'))}))", argument);
argument = attribute.Fields.Where(a => a.Name == "PanPan").First();
AssertCustomAttributeArgument("(String[]:{(String:\"yo\"), (String:\"yo\")})", argument);
Assert.AreEqual(2, attribute.Properties.Count);
argument = attribute.Properties.Where(a => a.Name == "Bang").First();
AssertArgument(42, argument);
argument = attribute.Properties.Where(a => a.Name == "Fiou").First();
AssertArgument <string> (null, argument);
}
public void ArrayMarshaler()
{
var module = SampleInputLoader.LoadAssembly("marshal").MainModule;
var bar = module.GetType("Bar");
var pan = bar.GetMethod("PanPan");
var parameter = pan.Parameters [1];
Assert.IsTrue(parameter.HasMarshalInfo);
var info = (ArrayMarshalInfo)parameter.MarshalInfo;
Assert.AreEqual(NativeType.I8, info.ElementType);
Assert.AreEqual(66, info.Size);
Assert.AreEqual(2, info.SizeParameterIndex);
parameter = pan.Parameters [3];
Assert.IsTrue(parameter.HasMarshalInfo);
info = (ArrayMarshalInfo)parameter.MarshalInfo;
Assert.AreEqual(NativeType.I2, info.ElementType);
Assert.AreEqual(-1, info.Size);
Assert.AreEqual(-1, info.SizeParameterIndex);
}
public void CharArray()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("CustomAttributes").MainModule;
var rifle = module.GetType("Rifle");
var attribute = GetAttribute(rifle, "Foo");
Assert.IsNotNull(attribute);
var argument = attribute.ConstructorArguments [0];
Assert.AreEqual("System.Char[]", argument.Type.FullName);
var array = argument.Value as CustomAttributeArgument [];
Assert.IsNotNull(array);
var str = "cecil";
Assert.AreEqual(array.Length, str.Length);
for (int i = 0; i < str.Length; i++)
{
AssertArgument(str [i], array [i]);
}
}
public void ConstantCoalescing()
{
var module = SampleInputLoader.LoadAssembly("types").MainModule;
var fields = module.GetType("Fields");
var field = fields.GetField("int32_int16");
Assert.AreEqual("System.Int32", field.FieldType.FullName);
Assert.IsTrue(field.HasConstant);
Assert.IsInstanceOfType(field.Constant, typeof(short));
Assert.AreEqual((short)1, field.Constant);
field = fields.GetField("int16_int32");
Assert.AreEqual("System.Int16", field.FieldType.FullName);
Assert.IsTrue(field.HasConstant);
Assert.IsInstanceOfType(field.Constant, typeof(int));
Assert.AreEqual(1, field.Constant);
field = fields.GetField("char_int16");
Assert.AreEqual("System.Char", field.FieldType.FullName);
Assert.IsTrue(field.HasConstant);
Assert.IsInstanceOfType(field.Constant, typeof(short));
Assert.AreEqual((short)1, field.Constant);
field = fields.GetField("int16_char");
Assert.AreEqual("System.Int16", field.FieldType.FullName);
Assert.IsTrue(field.HasConstant);
Assert.IsInstanceOfType(field.Constant, typeof(char));
Assert.AreEqual('s', field.Constant);
}
public void FieldLayout()
{
var module = SampleInputLoader.LoadAssembly("Layouts").MainModule;
var foo = module.GetType("Foo");
Assert.IsNotNull(foo);
Assert.IsTrue(foo.HasFields);
var fields = foo.Fields;
var field = fields [0];
Assert.AreEqual("Bar", field.Name);
Assert.IsTrue(field.HasLayoutInfo);
Assert.AreEqual(0, field.Offset);
field = fields [1];
Assert.AreEqual("Baz", field.Name);
Assert.IsTrue(field.HasLayoutInfo);
Assert.AreEqual(2, field.Offset);
field = fields [2];
Assert.AreEqual("Gazonk", field.Name);
Assert.IsTrue(field.HasLayoutInfo);
Assert.AreEqual(4, field.Offset);
}
public void ArrayFields()
{
var module = SampleInputLoader.LoadAssembly("types").MainModule;
var types = module.GetType("Types");
Assert.IsNotNull(types);
var rank_two = types.GetField("rank_two");
var array = rank_two.FieldType as ArrayType;
Assert.IsNotNull(array);
Assert.AreEqual(2, array.Rank);
Assert.IsFalse(array.Dimensions [0].IsSized);
Assert.IsFalse(array.Dimensions [1].IsSized);
var rank_two_low_bound_zero = types.GetField("rank_two_low_bound_zero");
array = rank_two_low_bound_zero.FieldType as ArrayType;
Assert.IsNotNull(array);
Assert.AreEqual(2, array.Rank);
Assert.IsTrue(array.Dimensions [0].IsSized);
Assert.AreEqual(0, array.Dimensions [0].LowerBound);
Assert.AreEqual(null, array.Dimensions [0].UpperBound);
Assert.IsTrue(array.Dimensions [1].IsSized);
Assert.AreEqual(0, array.Dimensions [1].LowerBound);
Assert.AreEqual(null, array.Dimensions [1].UpperBound);
}
public void OtherMethod()
{
var module = SampleInputLoader.LoadAssembly("others").MainModule;
var type = module.GetType("Others");
Assert.IsTrue(type.HasProperties);
var properties = type.Properties;
Assert.AreEqual(1, properties.Count);
var property = properties [0];
Assert.IsNotNull(property);
Assert.AreEqual("Context", property.Name);
Assert.IsNotNull(property.PropertyType);
Assert.AreEqual("System.String", property.PropertyType.FullName);
Assert.IsTrue(property.HasOtherMethods);
Assert.AreEqual(2, property.OtherMethods.Count);
var other = property.OtherMethods [0];
Assert.AreEqual("let_Context", other.Name);
other = property.OtherMethods [1];
Assert.AreEqual("bet_Context", other.Name);
}
public void ReturnGenericInstance()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("GenericsAsm").MainModule;
var bar = module.GetType("Bar`1");
var self = bar.GetMethod("Self");
Assert.IsNotNull(self);
var bar_t = self.ReturnType;
Assert.IsTrue(bar_t.IsGenericInstance);
var bar_t_instance = (GenericInstanceType)bar_t;
Assert.AreEqual(bar.GenericParameters [0], bar_t_instance.GenericArguments [0]);
var self_str = bar.GetMethod("SelfString");
Assert.IsNotNull(self_str);
var bar_str = self_str.ReturnType;
Assert.IsTrue(bar_str.IsGenericInstance);
var bar_str_instance = (GenericInstanceType)bar_str;
Assert.AreEqual("System.String", bar_str_instance.GenericArguments [0].FullName);
}
public void VarArgs()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("varargs").MainModule;
var module_type = module.Types [0];
Assert.AreEqual(3, module_type.Methods.Count);
var bar = module_type.GetMethod("Bar");
var baz = module_type.GetMethod("Baz");
var foo = module_type.GetMethod("Foo");
Assert.IsTrue((bar.CallingConvention & MethodCallingConvention.VarArg) != 0);
Assert.IsFalse((baz.CallingConvention & MethodCallingConvention.VarArg) != 0);
Assert.IsTrue((foo.CallingConvention & MethodCallingConvention.VarArg) != 0);
var bar_reference = (MethodReference)baz.Body.Instructions.Where(i => i.Offset == 0x000a).First().Operand;
Assert.IsTrue((bar_reference.CallingConvention & MethodCallingConvention.VarArg) != 0);
Assert.IsTrue(bar_reference.Parameters[0].ParameterType.IsSentinel);
var foo_reference = (MethodReference)baz.Body.Instructions.Where(i => i.Offset == 0x0023).First().Operand;
Assert.IsTrue((foo_reference.CallingConvention & MethodCallingConvention.VarArg) != 0);
Assert.IsFalse(foo_reference.Parameters[0].ParameterType.IsSentinel);
Assert.IsTrue(foo_reference.Parameters[1].ParameterType.IsSentinel);
}
public void SimpleOverrides()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("Interfaces").MainModule;
var ibingo = module.GetType("IBingo");
var ibingo_foo = ibingo.GetMethod("Foo");
Assert.IsNotNull(ibingo_foo);
var ibingo_bar = ibingo.GetMethod("Bar");
Assert.IsNotNull(ibingo_bar);
var bingo = module.GetType("Bingo");
var foo = bingo.GetMethod("IBingo.Foo");
Assert.IsNotNull(foo);
Assert.IsTrue(foo.HasOverrides);
Assert.AreEqual(ibingo_foo, foo.Overrides [0]);
var bar = bingo.GetMethod("IBingo.Bar");
Assert.IsNotNull(bar);
Assert.IsTrue(bar.HasOverrides);
Assert.AreEqual(ibingo_bar, bar.Overrides [0]);
}
public void TestOthersIL()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("Others").MainModule;
var type = module.GetType("Others");
Assert.IsTrue(type.HasEvents);
var events = type.Events;
Assert.AreEqual(1, events.Count);
var @event = events [0];
Assert.IsNotNull(@event);
Assert.AreEqual("Handler", @event.Name);
Assert.IsNotNull(@event.EventType);
Assert.AreEqual("System.EventHandler", @event.EventType.FullName);
Assert.IsTrue(@event.HasOtherMethods);
Assert.AreEqual(2, @event.OtherMethods.Count);
var other = @event.OtherMethods [0];
Assert.AreEqual("dang_Handler", other.Name);
other = @event.OtherMethods [1];
Assert.AreEqual("fang_Handler", other.Name);
}
public void EmbeddedResource()
{
var assembly = SampleInputLoader.LoadAssembly("libres");
var module = assembly.MainModule;
var resource = module.Resources.Where(res => res.Name == "embedded1.txt").First() as EmbeddedResource;
Assert.IsNotNull(resource);
Assert.AreEqual("embedded1.txt", resource.Name);
Assert.AreEqual(ResourceType.Embedded, resource.ResourceType);
Assert.IsTrue(resource.IsPublic);
using (var reader = new StreamReader(resource.GetResourceStream()))
Assert.AreEqual("Hello", reader.ReadToEnd());
resource = module.Resources.Where(res => res.Name == "embedded2.txt").First() as EmbeddedResource;
Assert.IsNotNull(resource);
Assert.AreEqual("embedded2.txt", resource.Name);
Assert.AreEqual(ResourceType.Embedded, resource.ResourceType);
Assert.IsTrue(resource.IsPublic);
using (var reader = new StreamReader(resource.GetResourceStream()))
Assert.AreEqual("World", reader.ReadToEnd());
}
public void DirectNestedType()
{
var module = SampleInputLoader.LoadAssembly("NestedTypes").MainModule;
var bingo = module.GetType("Bingo");
var get_fuel = bingo.GetMethod("GetFuel");
Assert.AreEqual("Bingo/Fuel", get_fuel.ReturnType.FullName);
}
public void SingleModule()
{
var assembly = SampleInputLoader.LoadAssembly("hello");
var module = assembly.MainModule;
Assert.AreEqual(1, assembly.Modules.Count);
Assert.IsNotNull(assembly.MainModule);
}
public void ModuleReferences()
{
var assembly = SampleInputLoader.LoadAssembly("pinvoke");
var module = assembly.MainModule;
Assert.AreEqual(2, module.ModuleReferences.Count);
Assert.AreEqual("kernel32.dll", module.ModuleReferences [0].Name);
Assert.AreEqual("shell32.dll", module.ModuleReferences [1].Name);
}
public void BoxedDefaultArgumentValue()
{
var module = SampleInputLoader.LoadAssembly("boxedoptarg").MainModule;
var foo = module.GetType("Foo");
var bar = foo.GetMethod("Bar");
var baz = bar.Parameters [0];
Assert.IsTrue(baz.HasConstant);
Assert.AreEqual(-1, baz.Constant);
}
public void ModuleInformation()
{
var assembly = SampleInputLoader.LoadAssembly("hello");
var module = assembly.MainModule;
Assert.IsNotNull(module);
Assert.AreEqual("hello.exe", module.Name);
Assert.AreEqual(new Guid("C3BC2BD3-2576-4D00-A80E-465B5632415F"), module.Mvid);
}
public void NullPrimitiveConstant()
{
var module = SampleInputLoader.LoadAssembly("types").MainModule;
var fields = module.GetType("Fields");
var field = fields.GetField("int32_nullref");
Assert.IsTrue(field.HasConstant);
Assert.AreEqual(null, field.Constant);
}
public void Types()
{
var assembly = SampleInputLoader.LoadAssembly("hello");
var module = assembly.MainModule;
Assert.AreEqual(2, module.Types.Count);
Assert.AreEqual("<Module>", module.Types [0].FullName);
Assert.AreEqual("<Module>", module.GetType("<Module>").FullName);
Assert.AreEqual("Program", module.Types [1].FullName);
Assert.AreEqual("Program", module.GetType("Program").FullName);
}
public void EntryPoint()
{
var assembly = SampleInputLoader.LoadAssembly("hello");
var module = assembly.MainModule;
var entry_point = module.EntryPoint;
Assert.IsNotNull(entry_point);
Assert.AreEqual("System.Void Program::Main()", entry_point.ToString());
}
public void StringArgumentOnAssembly()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("CustomAttributes").MainModule;
var assembly = module.Assembly;
var attribute = GetAttribute(assembly, "Foo");
Assert.IsNotNull(attribute);
AssertArgument("bingo", attribute.ConstructorArguments [0]);
}
public void HasTypeReference()
{
var assembly = SampleInputLoader.LoadAssembly("CustomAttributes");
var module = assembly.MainModule;
Assert.IsTrue(module.HasTypeReference("System.Attribute"));
Assert.IsTrue(module.HasTypeReference("mscorlib", "System.Attribute"));
Assert.IsFalse(module.HasTypeReference("System.Core", "System.Attribute"));
Assert.IsFalse(module.HasTypeReference("System.Linq.Enumerable"));
}
public void BoxedArguments()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("CustomAttributes").MainModule;
var worm = module.GetType("Worm");
var attribute = GetAttribute(worm, "Foo");
Assert.IsNotNull(attribute);
Assert.AreEqual(".ctor ((Object:(String:\"2\")), (Object:(Int32:2)))", PrettyPrint(attribute));
}
public void TypeReferenceValueType()
{
var module = SampleInputLoader.LoadAssembly("Methods").MainModule;
var baz = module.GetType("Baz");
var method = baz.GetMethod("PrintAnswer");
var box = method.Body.Instructions.Where(i => i.OpCode == OpCodes.Box).First();
var int32 = (TypeReference)box.Operand;
Assert.IsTrue(int32.IsValueType);
}
public void Win32FileVersion()
{
var assembly = SampleInputLoader.LoadAssembly("libhello");
var module = assembly.MainModule;
//var version = FileVersionInfo.GetVersionInfo (module.FullyQualifiedName);
//Assert.AreEqual ("0.0.0.0", version.FileVersion);
Assert.Fail("FileVersionInfo is not available.");
}
public void NullString()
{
ModuleDefinition module = SampleInputLoader.LoadAssembly("CustomAttributes").MainModule;
var dentist = module.GetType("Dentist");
var attribute = GetAttribute(dentist, "Foo");
Assert.IsNotNull(attribute);
AssertArgument <string> (null, attribute.ConstructorArguments [0]);
}
public void SetOnlyIndexer()
{
var module = SampleInputLoader.LoadAssembly("Properties").MainModule;
var type = module.GetType("Bar");
var indexer = type.Properties.Where(property => property.Name == "Item").First();
var parameters = indexer.Parameters;
Assert.AreEqual(2, parameters.Count);
Assert.AreEqual("System.Int32", parameters [0].ParameterType.FullName);
Assert.AreEqual("System.String", parameters [1].ParameterType.FullName);
}
public void SafeArrayMarshaler()
{
var module = SampleInputLoader.LoadAssembly("marshal").MainModule;
var bar = module.GetType("Bar");
var pan = bar.GetMethod("PanPan");
Assert.IsTrue(pan.MethodReturnType.HasMarshalInfo);
var info = (SafeArrayMarshalInfo)pan.MethodReturnType.MarshalInfo;
Assert.AreEqual(VariantType.Dispatch, info.ElementType);
}
public void GenericInterfaceReference()
{
var module = SampleInputLoader.LoadAssembly("gifaceref").MainModule;
var type = module.GetType("Program");
var iface = type.Interfaces [0];
var instance = (GenericInstanceType)iface;
var owner = instance.ElementType;
Assert.AreEqual(1, instance.GenericArguments.Count);
Assert.AreEqual(1, owner.GenericParameters.Count);
}
