public void EncodingModifiers() { ITypeDefinition encoding = Mscorlib.GetTypeDefinition(typeof(Encoding)); Assert.AreEqual(Accessibility.Public, encoding.Accessibility); Assert.IsFalse(encoding.IsSealed); Assert.IsTrue(encoding.IsAbstract); IMethod getDecoder = encoding.Methods.Single(p => p.Name == "GetDecoder"); Assert.AreEqual(Accessibility.Public, getDecoder.Accessibility); Assert.IsFalse(getDecoder.IsStatic); Assert.IsFalse(getDecoder.IsAbstract); Assert.IsFalse(getDecoder.IsSealed); Assert.IsTrue(getDecoder.IsVirtual); Assert.IsFalse(getDecoder.IsOverride); IMethod getMaxByteCount = encoding.Methods.Single(p => p.Name == "GetMaxByteCount"); Assert.AreEqual(Accessibility.Public, getMaxByteCount.Accessibility); Assert.IsFalse(getMaxByteCount.IsStatic); Assert.IsTrue(getMaxByteCount.IsAbstract); Assert.IsFalse(getMaxByteCount.IsSealed); Assert.IsFalse(getMaxByteCount.IsVirtual); Assert.IsFalse(getMaxByteCount.IsOverride); IProperty encoderFallback = encoding.Properties.Single(p => p.Name == "EncoderFallback"); Assert.AreEqual(Accessibility.Public, encoderFallback.Accessibility); Assert.IsFalse(encoderFallback.IsStatic); Assert.IsFalse(encoderFallback.IsAbstract); Assert.IsFalse(encoderFallback.IsSealed); Assert.IsFalse(encoderFallback.IsVirtual); Assert.IsFalse(encoderFallback.IsOverride); }
public void DateTimeDefaultConstructor() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(DateTime)); Assert.IsFalse(c.Methods.Any(m => m.IsConstructor && m.Parameters.Count == 0)); // struct ctor isn't declared // but it is implicit: Assert.IsTrue(c.GetConstructors(ctx).Any(m => m.Parameters.Count == 0)); }
public void NestedTypesTest() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(Environment.SpecialFolder)); Assert.IsNotNull(c, "c is null"); Assert.AreEqual("System.Environment.SpecialFolder", c.FullName); Assert.AreEqual("System.Environment+SpecialFolder", c.ReflectionName); }
public void GenericPropertyTest() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(Comparer <>)); IProperty def = c.Properties.Single(p => p.Name == "Default"); ParameterizedType pt = (ParameterizedType)def.ReturnType.Resolve(ctx); Assert.AreEqual("System.Collections.Generic.Comparer", pt.FullName); Assert.AreEqual(c.TypeParameters[0], pt.TypeArguments[0]); }
public void InnerClassReferenceTest() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(Environment)); Assert.IsNotNull(c, "System.Environment not found"); ITypeReference rt = c.Methods.First(m => m.Name == "GetFolderPath").Parameters[0].Type; Assert.AreSame(c.NestedTypes.Single(ic => ic.Name == "SpecialFolder"), rt.Resolve(ctx)); }
public void StaticModifierTest() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(Environment)); Assert.IsNotNull(c, "System.Environment not found"); Assert.IsTrue(c.IsAbstract, "class should be abstract"); Assert.IsTrue(c.IsSealed, "class should be sealed"); Assert.IsTrue(c.IsStatic, "class should be static"); }
public void NoEncodingInfoDefaultConstructor() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(EncodingInfo)); // EncodingInfo only has an internal constructor Assert.IsFalse(c.Methods.Any(m => m.IsConstructor)); // and no implicit ctor should be added: Assert.AreEqual(0, c.GetConstructors(ctx).Count()); }
public void PointerTypeTest() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(IntPtr)); IMethod toPointer = c.Methods.Single(p => p.Name == "ToPointer"); Assert.AreEqual("System.Void*", toPointer.ReturnType.Resolve(ctx).ReflectionName); Assert.IsTrue(toPointer.ReturnType.Resolve(ctx) is PointerType); Assert.AreEqual("System.Void", ((PointerType)toPointer.ReturnType.Resolve(ctx)).ElementType.FullName); }
public void NestedClassInGenericClassTest() { ITypeDefinition dictionary = Mscorlib.GetTypeDefinition(typeof(Dictionary <,>)); Assert.IsNotNull(dictionary); ITypeDefinition valueCollection = Mscorlib.GetTypeDefinition(typeof(Dictionary <,> .ValueCollection)); Assert.IsNotNull(valueCollection); var dictionaryRT = new ParameterizedType(dictionary, new[] { Mscorlib.GetTypeDefinition(typeof(string)), Mscorlib.GetTypeDefinition(typeof(int)) }); IProperty valueProperty = dictionaryRT.GetProperties(ctx).Single(p => p.Name == "Values"); IType parameterizedValueCollection = valueProperty.ReturnType.Resolve(ctx); Assert.AreEqual("System.Collections.Generic.Dictionary`2+ValueCollection[[System.String],[System.Int32]]", parameterizedValueCollection.ReflectionName); Assert.AreSame(valueCollection, parameterizedValueCollection.GetDefinition()); }
public void UTF32EncodingModifiers() { ITypeDefinition encoding = Mscorlib.GetTypeDefinition(typeof(UTF32Encoding)); Assert.AreEqual(Accessibility.Public, encoding.Accessibility); Assert.IsTrue(encoding.IsSealed); Assert.IsFalse(encoding.IsAbstract); IMethod getDecoder = encoding.Methods.Single(p => p.Name == "GetDecoder"); Assert.AreEqual(Accessibility.Public, getDecoder.Accessibility); Assert.IsFalse(getDecoder.IsStatic); Assert.IsFalse(getDecoder.IsAbstract); Assert.IsFalse(getDecoder.IsSealed); Assert.IsFalse(getDecoder.IsVirtual); Assert.IsTrue(getDecoder.IsOverride); }
public void ValueCollectionCountModifiers() { ITypeDefinition valueCollection = Mscorlib.GetTypeDefinition(typeof(Dictionary <,> .ValueCollection)); Assert.AreEqual(Accessibility.Public, valueCollection.Accessibility); Assert.IsTrue(valueCollection.IsSealed); Assert.IsFalse(valueCollection.IsAbstract); Assert.IsFalse(valueCollection.IsStatic); IProperty count = valueCollection.Properties.Single(p => p.Name == "Count"); Assert.AreEqual(Accessibility.Public, count.Accessibility); // It's sealed on the IL level; but in C# it's just a normal non-virtual method that happens to implement an interface Assert.IsFalse(count.IsSealed); Assert.IsFalse(count.IsVirtual); Assert.IsFalse(count.IsAbstract); }
public void VoidTest() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(void)); Assert.IsNotNull(c, "System.Void not found"); Assert.AreEqual(0, c.GetMethods(ctx).Count()); Assert.AreEqual(0, c.GetProperties(ctx).Count()); Assert.AreEqual(0, c.GetEvents(ctx).Count()); Assert.AreEqual(0, c.GetFields(ctx).Count()); Assert.AreEqual( new string[] { "[System.SerializableAttribute]", "[System.Runtime.InteropServices.StructLayoutAttribute(0, Size=1)]", "[System.Runtime.InteropServices.ComVisibleAttribute(true)]" }, c.Attributes.Select(a => a.ToString()).ToArray()); }
public void MathAcosModifiers() { ITypeDefinition math = Mscorlib.GetTypeDefinition(typeof(Math)); Assert.AreEqual(Accessibility.Public, math.Accessibility); Assert.IsTrue(math.IsSealed); Assert.IsTrue(math.IsAbstract); Assert.IsTrue(math.IsStatic); IMethod acos = math.Methods.Single(p => p.Name == "Acos"); Assert.AreEqual(Accessibility.Public, acos.Accessibility); Assert.IsTrue(acos.IsStatic); Assert.IsFalse(acos.IsAbstract); Assert.IsFalse(acos.IsSealed); Assert.IsFalse(acos.IsVirtual); Assert.IsFalse(acos.IsOverride); }
public void InheritanceTest() { ITypeDefinition c = Mscorlib.GetTypeDefinition(typeof(SystemException)); ITypeDefinition c2 = Mscorlib.GetTypeDefinition(typeof(Exception)); Assert.IsNotNull(c, "c is null"); Assert.IsNotNull(c2, "c2 is null"); //Assert.AreEqual(3, c.BaseTypes.Count); // Inherited interfaces are not reported by Cecil // which matches the behaviour of our C#/VB parsers Assert.AreEqual("System.Exception", c.BaseTypes[0].Resolve(ctx).FullName); Assert.AreSame(c2, c.BaseTypes[0]); string[] superTypes = c.GetAllBaseTypes(ctx).Select(t => t.ToString()).ToArray(); Assert.AreEqual(new string[] { "System.Object", "System.Runtime.Serialization.ISerializable", "System.Runtime.InteropServices._Exception", "System.Exception", "System.SystemException" }, superTypes); }
public void FixtureSetUp() { compilation = new SimpleCompilation(TestAssembly, Mscorlib.WithOptions(TypeSystemOptions.Default)); language = new CSharpLanguage(); }
private Type ImportImpl(System.Type type) { if (type.Assembly == typeof(IKVM.Reflection.Type).Assembly) { throw new ArgumentException("Did you really want to import " + type.FullName + "?"); } if (type.HasElementType) { if (type.IsArray) { if (type.Name.EndsWith("[]")) { return(Import(type.GetElementType()).MakeArrayType()); } else { return(Import(type.GetElementType()).MakeArrayType(type.GetArrayRank())); } } else if (type.IsByRef) { return(Import(type.GetElementType()).MakeByRefType()); } else if (type.IsPointer) { return(Import(type.GetElementType()).MakePointerType()); } else { throw new InvalidOperationException(); } } else if (type.IsGenericParameter) { if (type.DeclaringMethod != null) { throw new NotImplementedException(); } else { return(Import(type.DeclaringType).GetGenericArguments()[type.GenericParameterPosition]); } } else if (type.IsGenericType && !type.IsGenericTypeDefinition) { System.Type[] args = type.GetGenericArguments(); Type[] importedArgs = new Type[args.Length]; for (int i = 0; i < args.Length; i++) { importedArgs[i] = Import(args[i]); } return(Import(type.GetGenericTypeDefinition()).MakeGenericType(importedArgs)); } else if (type.IsNested) { // note that we can't pass in the namespace here, because .NET's Type.Namespace implementation is broken for nested types // (it returns the namespace of the declaring type) return(Import(type.DeclaringType).ResolveNestedType(new TypeName(null, type.Name))); } else if (type.Assembly == typeof(object).Assembly) { // make sure mscorlib types always end up in our mscorlib return(Mscorlib.ResolveType(new TypeName(type.Namespace, type.Name))); } else { return(Import(type.Assembly).ResolveType(new TypeName(type.Namespace, type.Name))); } }
internal void Emit(OpCode opCode, Label builder) { var real = Mscorlib.GetType("System.Reflection.Emit.Label"); this.Invoke("Emit", new Type[] { typeof(OpCode), real }, opCode, builder.Inner); }