public void TestSimpleNames() { { TypeDesc result = _testModule.GetTypeByCustomAttributeTypeName("TypeNameParsing.Simple"); Assert.Equal(_simpleType, result); } { TypeDesc result = _testModule.GetTypeByCustomAttributeTypeName("TypeNameParsing.Simple+Nested"); Assert.Equal(_nestedType, result); } { TypeDesc result = _testModule.GetTypeByCustomAttributeTypeName("TypeNameParsing.Simple+Nested+NestedTwice"); Assert.Equal(_nestedTwiceType, result); } { TypeDesc result = _testModule.GetTypeByCustomAttributeTypeName("System.Int32, " + _coreAssemblyQualifier); Assert.Equal(_context.GetWellKnownType(WellKnownType.Int32), result); } { TypeDesc result = _testModule.GetTypeByCustomAttributeTypeName("TypeNameParsing.VeryGeneric`3"); Assert.Equal(_veryGenericType, result); } }
public void TestAutoTypeLayoutMinPacking(WellKnownType type, int expectedSize) { MetadataType minPackingType = _testModule.GetType("Auto", "MinPacking`1"); InstantiatedType inst = minPackingType.MakeInstantiatedType(_context.GetWellKnownType(type)); Assert.Equal(expectedSize, inst.InstanceFieldSize.AsInt); }
public void TestMultidimensionalArrays() { DefType systemArrayType = _context.GetWellKnownType(WellKnownType.Array); TypeDesc objectType = _context.GetWellKnownType(WellKnownType.Object); ArrayType objectMDArray = _context.GetArrayType(objectType, 2); // MD array should have the same set of interfaces as System.Array Assert.Equal(systemArrayType.RuntimeInterfaces, objectMDArray.RuntimeInterfaces); }
public ValueTypeShapeCharacteristicsTests() { _context = new TestTypeSystemContext(TargetArchitecture.X64); var systemModule = _context.CreateModuleForSimpleName("CoreTestAssembly"); _context.SetSystemModule(systemModule); _testModule = systemModule; _singleType = _context.GetWellKnownType(WellKnownType.Single); _doubleType = _context.GetWellKnownType(WellKnownType.Double); }
public VirtualFunctionOverrideTests() { _context = new TestTypeSystemContext(TargetArchitecture.X64); var systemModule = _context.CreateModuleForSimpleName("CoreTestAssembly"); _context.SetSystemModule(systemModule); _testModule = systemModule; _stringType = _context.GetWellKnownType(WellKnownType.String); _voidType = _context.GetWellKnownType(WellKnownType.Void); }
public void TestHfaPrimitives() { DefType singleType = _context.GetWellKnownType(WellKnownType.Single); DefType doubleType = _context.GetWellKnownType(WellKnownType.Double); Assert.True(singleType.IsHomogeneousAggregate); Assert.Equal(Float32Aggregate, singleType.ValueTypeShapeCharacteristics); Assert.True(doubleType.IsHomogeneousAggregate); Assert.Equal(Float64Aggregate, doubleType.ValueTypeShapeCharacteristics); }
public VirtualFunctionOverrideTests() { _context = new TestTypeSystemContext(TargetArchitecture.X64); var systemModule = _context.CreateModuleForSimpleName("CoreTestAssembly"); _context.SetSystemModule(systemModule); _testModule = systemModule; _stringType = _context.GetWellKnownType(WellKnownType.String); _voidType = _context.GetWellKnownType(WellKnownType.Void); }
public ValueTypeShapeCharacteristicsTests() { _context = new TestTypeSystemContext(TargetArchitecture.ARM); var systemModule = _context.CreateModuleForSimpleName("CoreTestAssembly"); _context.SetSystemModule(systemModule); _testModule = systemModule; _singleType = _context.GetWellKnownType(WellKnownType.Single); _doubleType = _context.GetWellKnownType(WellKnownType.Double); }
public void TestMultidimensionalArrays() { DefType systemArrayType = _context.GetWellKnownType(WellKnownType.Array); TypeDesc objectType = _context.GetWellKnownType(WellKnownType.Object); ArrayType objectMDArrayRank1 = _context.GetArrayType(objectType, 1); ArrayType objectMDArrayRank2 = _context.GetArrayType(objectType, 2); ArrayType objectMDArrayRank3 = _context.GetArrayType(objectType, 3); Assert.Equal(TypeHashingAlgorithms.ComputeArrayTypeHashCode(objectType.GetHashCode(), 1), objectMDArrayRank1.GetHashCode()); Assert.Equal(TypeHashingAlgorithms.ComputeArrayTypeHashCode(objectType.GetHashCode(), 2), objectMDArrayRank2.GetHashCode()); Assert.Equal(TypeHashingAlgorithms.ComputeArrayTypeHashCode(objectType.GetHashCode(), 3), objectMDArrayRank3.GetHashCode()); }
public void TestSerializedSignatureWithReferenceToMDIntArray() { var typeInInitialContext = _context.GetWellKnownType(WellKnownType.Int32).MakeArrayType(3); // Create assembly with reference to interesting type TypeSystemMetadataEmitter metadataEmitter = new TypeSystemMetadataEmitter(new System.Reflection.AssemblyName("Lookup"), _context); var token = metadataEmitter.GetTypeRef(typeInInitialContext); Stream peStream = new MemoryStream(); metadataEmitter.SerializeToStream(peStream); peStream.Seek(0, SeekOrigin.Begin); // Create new TypeSystemContext with just created assembly inside var lookupContext = new TestTypeSystemContext(TargetArchitecture.X64); var systemModule = lookupContext.CreateModuleForSimpleName("CoreTestAssembly"); lookupContext.SetSystemModule(systemModule); lookupContext.CreateModuleForSimpleName("Lookup", peStream); // Use generated assembly to trigger a load through the token created above and verify that it loads correctly var ilLookupModule = (EcmaModule)lookupContext.GetModuleForSimpleName("Lookup"); TypeDesc int32ArrayFromLookup = ilLookupModule.GetType(token); var typeInLookupContext = lookupContext.GetWellKnownType(WellKnownType.Int32).MakeArrayType(3); Assert.Equal(typeInLookupContext, int32ArrayFromLookup); }
public void TestHfaNegative() { var nonHfaEmptyStruct = _testModule.GetType("ValueTypeShapeCharacteristics", "NonHfaEmptyStruct"); Assert.False(nonHfaEmptyStruct.IsHfa); var nonHfaStruct = _testModule.GetType("ValueTypeShapeCharacteristics", "NonHfaStruct"); Assert.False(nonHfaStruct.IsHfa); var nonHfaMixedStruct = _testModule.GetType("ValueTypeShapeCharacteristics", "NonHfaMixedStruct"); Assert.False(nonHfaMixedStruct.IsHfa); var nonHfaCompositeStruct = _testModule.GetType("ValueTypeShapeCharacteristics", "NonHfaCompositeStruct"); Assert.False(nonHfaCompositeStruct.IsHfa); var nonHfaStructWithManyFields = _testModule.GetType("ValueTypeShapeCharacteristics", "NonHfaStructWithManyFields"); Assert.False(nonHfaStructWithManyFields.IsHfa); var objectType = _context.GetWellKnownType(WellKnownType.Object); Assert.False(objectType.IsHfa); }
public void TestVirtualDispatchOnGenericType() { // Verifies that virtual dispatch to a non-generic method on a generic instantiation works DefType objectType = _context.GetWellKnownType(WellKnownType.Object); MethodSignature toStringSig = new MethodSignature(MethodSignatureFlags.None, 0, _stringType, Array.Empty <TypeDesc>()); MethodDesc objectToString = objectType.GetMethod("ToString", toStringSig); Assert.NotNull(objectToString); MetadataType openTestType = _testModule.GetType("VirtualFunctionOverride", "SimpleGeneric`1"); InstantiatedType testInstance = openTestType.MakeInstantiatedType(objectType); MethodDesc targetOnInstance = testInstance.GetMethod("ToString", toStringSig); MethodDesc targetMethod = testInstance.FindVirtualFunctionTargetMethodOnObjectType(objectToString); Assert.Equal(targetOnInstance, targetMethod); }
public void TestInstantiation() { MetadataType t = _testModule.GetType("GenericTypes", "GenericClass`1"); // Verify that we get just type definitions. Assert.NotNull(t); Assert.True(t.IsTypeDefinition); Assert.NotNull(t.Instantiation); Assert.Equal(t.Instantiation.Length, 1); Assert.True(t.Instantiation[0].IsTypeDefinition); // Verify that we got a method definition MethodDesc fooMethod = t.GetMethods().First(m => m.Name == "Foo"); Assert.True(fooMethod.IsTypicalMethodDefinition); // Verify that instantiating a method definition has no effect MethodDesc instantiatedMethod = fooMethod.InstantiateSignature(new Instantiation(_context.GetWellKnownType(WellKnownType.Int32)), Instantiation.Empty); Assert.Same(fooMethod, instantiatedMethod); MetadataType instantiatedType = t.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Int32)); // Verify properties of the instantiated type Assert.NotNull(instantiatedType); Assert.False(instantiatedType.IsTypeDefinition); Assert.NotNull(instantiatedType.Instantiation); Assert.Equal(instantiatedType.Instantiation.Length, 1); Assert.Equal(instantiatedType.Instantiation[0], _context.GetWellKnownType(WellKnownType.Int32)); // Verify that we get an instantiated method with the proper signature MethodDesc fooInstantiatedMethod = instantiatedType.GetMethods().First(m => m.Name == "Foo"); Assert.False(fooInstantiatedMethod.IsTypicalMethodDefinition); Assert.Equal(fooInstantiatedMethod.Signature.ReturnType, _context.GetWellKnownType(WellKnownType.Int32)); Assert.Same(fooInstantiatedMethod.GetTypicalMethodDefinition(), fooMethod); // This is not a generic method, so they should be the same Assert.Same(fooInstantiatedMethod.GetMethodDefinition(), fooInstantiatedMethod); // Verify that instantiating a type definition has no effect TypeDesc newType = t.InstantiateSignature(new Instantiation(_context.GetWellKnownType(WellKnownType.Int32)), Instantiation.Empty); Assert.NotNull(newType); Assert.Same(newType, t); }
public void TestMetadataEnumerationAlgorithm() { var algo = new MetadataVirtualMethodEnumerationAlgorithm(); DefType objectType = _context.GetWellKnownType(WellKnownType.Object); var objectMethods = algo.ComputeAllVirtualMethods(objectType).ToArray(); Assert.Equal(4, objectMethods.Length); Assert.Superset(new HashSet <string> { "Equals", "GetHashCode", "ToString", "Finalize" }, new HashSet <string>(objectMethods.Select(m => m.Name))); var testTypeMethods = algo.ComputeAllVirtualMethods(_testType).ToArray(); Assert.Equal(1, testTypeMethods.Length); Assert.Equal("ToString", testTypeMethods[0].Name); Assert.Equal(_testType, testTypeMethods[0].OwningType); }
public VirtualMethodEnumerationAlgorithmTests() { _context = new TestTypeSystemContext(TargetArchitecture.Unknown); var systemModule = _context.CreateModuleForSimpleName("CoreTestAssembly"); _context.SetSystemModule(systemModule); _testModule = systemModule; _testType = _testModule.GetType("VirtualFunctionOverride", "SimpleGeneric`1") .MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Object)); }
public VirtualMethodEnumerationAlgorithmTests() { _context = new TestTypeSystemContext(TargetArchitecture.Unknown); var systemModule = _context.CreateModuleForSimpleName("CoreTestAssembly"); _context.SetSystemModule(systemModule); _testModule = systemModule; _testType = _testModule.GetType("VirtualFunctionOverride", "SimpleGeneric`1") .MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Object)); }
public void TestByRefLikeTypes() { { DefType type = _context.GetWellKnownType(WellKnownType.TypedReference); Assert.True(type.IsByRefLike); } { DefType type = _context.GetWellKnownType(WellKnownType.ByReferenceOfT); Assert.True(type.IsByRefLike); } { DefType type = _testModule.GetType("IsByRefLike", "ByRefLikeStruct"); Assert.True(type.IsByRefLike); } { DefType type = _testModule.GetType("IsByRefLike", "NotByRefLike"); Assert.False(type.IsByRefLike); } }
public void TestTypeConstraints() { MetadataType instantiatedType; MetadataType arg2OfInt = _arg2Type.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Int32)); MetadataType arg2OfBool = _arg2Type.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Boolean)); MetadataType arg2OfObject = _arg2Type.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Object)); // ReferenceTypeConstraint { instantiatedType = _referenceTypeConstraintType.MakeInstantiatedType(_arg1Type); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _referenceTypeConstraintType.MakeInstantiatedType(_iNonGenType); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _referenceTypeConstraintType.MakeInstantiatedType(_structArgWithDefaultCtorType); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _referenceTypeConstraintType.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Int32)); Assert.False(instantiatedType.CheckConstraints()); } // DefaultConstructorConstraint { instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_arg1Type); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_classArgWithDefaultCtorType); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_classArgWithPrivateDefaultCtorType); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_abstractClassArgWithDefaultCtorType); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_classArgWithoutDefaultCtorType); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Int32)); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_structArgWithDefaultCtorType); Assert.True(instantiatedType.CheckConstraints()); // Structs always have implicit default constructors instantiatedType = _defaultConstructorConstraintType.MakeInstantiatedType(_structArgWithoutDefaultCtorType); Assert.True(instantiatedType.CheckConstraints()); } // NotNullableValueTypeConstraint { instantiatedType = _notNullableValueTypeConstraintType.MakeInstantiatedType(_arg1Type); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _notNullableValueTypeConstraintType.MakeInstantiatedType(_structArgWithDefaultCtorType); Assert.True(instantiatedType.CheckConstraints()); MetadataType nullable = (MetadataType)_context.GetWellKnownType(WellKnownType.Nullable); MetadataType nullableOfInt = nullable.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Int32)); instantiatedType = _notNullableValueTypeConstraintType.MakeInstantiatedType(nullableOfInt); Assert.False(instantiatedType.CheckConstraints()); } // SimpleTypeConstraint and DoubleSimpleTypeConstraint foreach (var genType in new MetadataType[] { _simpleTypeConstraintType, _doubleSimpleTypeConstraintType }) { instantiatedType = genType.MakeInstantiatedType(_arg1Type); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = genType.MakeInstantiatedType(_iNonGenType); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = genType.MakeInstantiatedType(_classArgWithDefaultCtorType); Assert.False(instantiatedType.CheckConstraints()); } // SimpleGenericConstraint { instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_arg1Type, _arg1Type); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_arg1Type, _iNonGenType); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_classArgWithDefaultCtorType, _classArgWithoutDefaultCtorType); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_arg1Type, _context.GetWellKnownType(WellKnownType.Object)); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_structArgWithDefaultCtorType, _context.GetWellKnownType(WellKnownType.ValueType)); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_arg1Type, _context.GetWellKnownType(WellKnownType.ValueType)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.UInt16), _context.GetWellKnownType(WellKnownType.UInt32)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _simpleGenericConstraintType.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.UInt16), _context.GetWellKnownType(WellKnownType.ValueType)); Assert.True(instantiatedType.CheckConstraints()); } // ComplexGenericConstraint1 { instantiatedType = _complexGenericConstraint1Type.MakeInstantiatedType(_arg1Type, _arg1Type /* uninteresting */); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint1Type.MakeInstantiatedType(arg2OfInt, _arg1Type /* uninteresting */); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint1Type.MakeInstantiatedType(arg2OfBool, _arg1Type /* uninteresting */); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint1Type.MakeInstantiatedType(arg2OfObject, _arg1Type /* uninteresting */); Assert.False(instantiatedType.CheckConstraints()); } // ComplexGenericConstraint2 { MetadataType arg2OfArg2OfInt = _arg2Type.MakeInstantiatedType(arg2OfInt); MetadataType arg2OfArg2OfBool = _arg2Type.MakeInstantiatedType(arg2OfBool); MetadataType arg2OfArg2OfObject = _arg2Type.MakeInstantiatedType(arg2OfObject); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(_arg1Type, _context.GetWellKnownType(WellKnownType.Int32)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfInt, _context.GetWellKnownType(WellKnownType.Int32)); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfBool, _context.GetWellKnownType(WellKnownType.Int32)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfObject, _context.GetWellKnownType(WellKnownType.Int32)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfInt, _context.GetWellKnownType(WellKnownType.Object)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfBool, _context.GetWellKnownType(WellKnownType.Object)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfObject, _context.GetWellKnownType(WellKnownType.Object)); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfInt, _context.GetWellKnownType(WellKnownType.Boolean)); Assert.False(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfBool, _context.GetWellKnownType(WellKnownType.Boolean)); Assert.True(instantiatedType.CheckConstraints()); instantiatedType = _complexGenericConstraint2Type.MakeInstantiatedType(arg2OfArg2OfObject, _context.GetWellKnownType(WellKnownType.Boolean)); Assert.False(instantiatedType.CheckConstraints()); } // ComplexGenericConstraint3 { MetadataType igenOfObject = _iGenType.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Object)); instantiatedType = _complexGenericConstraint3Type.MakeInstantiatedType(igenOfObject, _context.GetWellKnownType(WellKnownType.Object)); Assert.True(instantiatedType.CheckConstraints()); // Variance-compatible instantiation argument instantiatedType = _complexGenericConstraint3Type.MakeInstantiatedType(igenOfObject, _context.GetWellKnownType(WellKnownType.String)); Assert.True(instantiatedType.CheckConstraints()); // Type that implements the interface var arg3OfObject = _arg3Type.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Object)); instantiatedType = _complexGenericConstraint3Type.MakeInstantiatedType(arg3OfObject, _context.GetWellKnownType(WellKnownType.Object)); Assert.True(instantiatedType.CheckConstraints()); // Type that implements a variant compatible interface instantiatedType = _complexGenericConstraint3Type.MakeInstantiatedType(arg3OfObject, _context.GetWellKnownType(WellKnownType.String)); Assert.True(instantiatedType.CheckConstraints()); } // MultipleConstraints { // Violate the class constraint instantiatedType = _multipleConstraintsType.MakeInstantiatedType(_structArgWithDefaultCtorType, _context.GetWellKnownType(WellKnownType.Object)); Assert.False(instantiatedType.CheckConstraints()); // Violate the new() constraint instantiatedType = _multipleConstraintsType.MakeInstantiatedType(_classArgWithoutDefaultCtorType, _context.GetWellKnownType(WellKnownType.Object)); Assert.False(instantiatedType.CheckConstraints()); // Violate the IGen<U> constraint instantiatedType = _multipleConstraintsType.MakeInstantiatedType(_arg1Type, _context.GetWellKnownType(WellKnownType.Object)); Assert.False(instantiatedType.CheckConstraints()); // Satisfy all constraints instantiatedType = _multipleConstraintsType.MakeInstantiatedType(_classArgWithDefaultCtorType, _context.GetWellKnownType(WellKnownType.Object)); Assert.True(instantiatedType.CheckConstraints()); } // InvalidInstantiationArgs { var pointer = _context.GetWellKnownType(WellKnownType.Int16).MakePointerType(); var byref = _context.GetWellKnownType(WellKnownType.Int16).MakeByRefType(); Assert.False(_iGenType.Instantiation.CheckValidInstantiationArguments()); instantiatedType = _iGenType.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Void)); Assert.False(instantiatedType.Instantiation.CheckValidInstantiationArguments()); instantiatedType = _iGenType.MakeInstantiatedType(pointer); Assert.False(instantiatedType.Instantiation.CheckValidInstantiationArguments()); instantiatedType = _iGenType.MakeInstantiatedType(byref); Assert.False(instantiatedType.Instantiation.CheckValidInstantiationArguments()); instantiatedType = _iGenType.MakeInstantiatedType(byref); instantiatedType = _iGenType.MakeInstantiatedType(instantiatedType); Assert.False(instantiatedType.Instantiation.CheckValidInstantiationArguments()); } }
public void TestIsValueType() { Assert.True(_context.GetWellKnownType(WellKnownType.Boolean).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Char).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.SByte).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Byte).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Int16).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.UInt16).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Int32).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.UInt32).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Int64).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.UInt64).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.IntPtr).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.UIntPtr).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Single).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Double).IsValueType); Assert.False(_context.GetWellKnownType(WellKnownType.ValueType).IsValueType); Assert.False(_context.GetWellKnownType(WellKnownType.Enum).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.Nullable).IsValueType); Assert.False(_context.GetWellKnownType(WellKnownType.Object).IsValueType); Assert.False(_context.GetWellKnownType(WellKnownType.String).IsValueType); Assert.False(_context.GetWellKnownType(WellKnownType.Array).IsValueType); Assert.False(_context.GetWellKnownType(WellKnownType.MulticastDelegate).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.RuntimeTypeHandle).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.RuntimeMethodHandle).IsValueType); Assert.True(_context.GetWellKnownType(WellKnownType.RuntimeFieldHandle).IsValueType); Assert.False(_context.GetWellKnownType(WellKnownType.Exception).IsValueType); }
public void TestArrayTypes(CanonicalizationMode algorithmType) { _context.CanonMode = algorithmType; // Generic type instantiated over an array has the same canonical form as generic type over any other reference type var genericStructOverArrayOfInt = _genericStructType.MakeInstantiatedType(_context.GetWellKnownType(WellKnownType.Int32).MakeArrayType()); var genericStructOverReferenceType = _genericStructType.MakeInstantiatedType(_referenceType); Assert.Same( genericStructOverArrayOfInt.ConvertToCanonForm(CanonicalFormKind.Specific), genericStructOverReferenceType.ConvertToCanonForm(CanonicalFormKind.Specific)); Assert.Same( genericStructOverArrayOfInt.ConvertToCanonForm(CanonicalFormKind.Universal), genericStructOverReferenceType.ConvertToCanonForm(CanonicalFormKind.Universal)); // Canonical form of SzArray and Multidim array are not the same var arrayOfReferenceType = _referenceType.MakeArrayType(); var mdArrayOfReferenceType = _referenceType.MakeArrayType(1); Assert.NotSame( arrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Specific), mdArrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Specific)); Assert.NotSame( arrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Universal), mdArrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Universal)); // Canonical forms of arrays over different reference types are same var arrayOfOtherReferenceType = _otherReferenceType.MakeArrayType(); Assert.Same( arrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Specific), arrayOfOtherReferenceType.ConvertToCanonForm(CanonicalFormKind.Specific)); Assert.Same( arrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Universal), arrayOfOtherReferenceType.ConvertToCanonForm(CanonicalFormKind.Universal)); // Canonical forms of arrays of value types are only same for universal canon form var arrayOfStruct = _structType.MakeArrayType(); Assert.NotSame( arrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Specific), arrayOfStruct.ConvertToCanonForm(CanonicalFormKind.Specific)); Assert.Same( arrayOfReferenceType.ConvertToCanonForm(CanonicalFormKind.Universal), arrayOfStruct.ConvertToCanonForm(CanonicalFormKind.Universal)); }
public void TestCastingInHierarchy() { TypeDesc objectType = _context.GetWellKnownType(WellKnownType.Object); TypeDesc stringType = _context.GetWellKnownType(WellKnownType.String); TypeDesc intType = _context.GetWellKnownType(WellKnownType.Int32); TypeDesc uintType = _context.GetWellKnownType(WellKnownType.UInt32); Assert.True(stringType.CanCastTo(objectType)); Assert.True(objectType.CanCastTo(objectType)); Assert.True(intType.CanCastTo(objectType)); Assert.False(objectType.CanCastTo(stringType)); Assert.False(intType.CanCastTo(uintType)); Assert.False(uintType.CanCastTo(intType)); }
public void IsBlittableType_BilittableWellKnownTypes_ReturnsTrue(WellKnownType type) => Assert.True(MarshalUtils.IsBlittableType(_context.GetWellKnownType(type)));
public static IEnumerable <object[]> VariantTestData() { var context = new TestTypeSystemContext(TargetArchitecture.Unknown); ModuleDesc testModule = context.CreateModuleForSimpleName("CoreTestAssembly"); context.SetSystemModule(testModule); MetadataType simple = testModule.GetType("VirtualStaticInterfaceMethods", "Simple"); MetadataType iSimple = testModule.GetType("VirtualStaticInterfaceMethods", "ISimple"); MetadataType iVariant = testModule.GetType("VirtualStaticInterfaceMethods", "IVariant`1"); MetadataType @base = testModule.GetType("VirtualStaticInterfaceMethods", "Base"); MetadataType mid = testModule.GetType("VirtualStaticInterfaceMethods", "Mid"); MetadataType derived = testModule.GetType("VirtualStaticInterfaceMethods", "Derived"); MetadataType simpleVariant = testModule.GetType("VirtualStaticInterfaceMethods", "SimpleVariant"); MetadataType simpleVariantTwice = testModule.GetType("VirtualStaticInterfaceMethods", "SimpleVariantTwice"); MetadataType variantWithInheritanceDerived = testModule.GetType("VirtualStaticInterfaceMethods", "VariantWithInheritanceDerived"); MetadataType genericVariantWithInheritanceDerived = testModule.GetType("VirtualStaticInterfaceMethods", "GenericVariantWithInheritanceDerived`1"); MetadataType genericVariantWithHiddenBase = testModule.GetType("VirtualStaticInterfaceMethods", "GenericVariantWithHiddenBase"); MetadataType genericVariantWithHiddenDerived = testModule.GetType("VirtualStaticInterfaceMethods", "GenericVariantWithHiddenDerived`1"); MethodDesc iSimpleMethod = iSimple.GetMethod("WhichMethod", null); MethodDesc iVariantBaseMethod = iVariant.MakeInstantiatedType(@base).GetMethod("WhichMethod", null); MethodDesc iVariantMidMethod = iVariant.MakeInstantiatedType(mid).GetMethod("WhichMethod", null); MethodDesc iVariantDerivedMethod = iVariant.MakeInstantiatedType(derived).GetMethod("WhichMethod", null); yield return(new object[] { simple, iSimpleMethod, simple.GetMethod("WhichMethod", null) }); yield return(new object[] { simpleVariant, iVariantBaseMethod, simpleVariant.GetMethod("WhichMethod", null) }); yield return(new object[] { simpleVariant, iVariantDerivedMethod, simpleVariant.GetMethod("WhichMethod", null) }); yield return(new object[] { simpleVariantTwice, iVariantBaseMethod, simpleVariantTwice.GetMethod("WhichMethod", new MethodSignature(MethodSignatureFlags.Static, 0, context.GetWellKnownType(WellKnownType.String), new TypeDesc[] { @base })) }); yield return(new object[] { simpleVariantTwice, iVariantMidMethod, simpleVariantTwice.GetMethod("WhichMethod", new MethodSignature(MethodSignatureFlags.Static, 0, context.GetWellKnownType(WellKnownType.String), new TypeDesc[] { mid })) }); yield return(new object[] { simpleVariantTwice, iVariantDerivedMethod, simpleVariantTwice.GetMethod("WhichMethod", new MethodSignature(MethodSignatureFlags.Static, 0, context.GetWellKnownType(WellKnownType.String), new TypeDesc[] { @base })) }); yield return(new object[] { variantWithInheritanceDerived, iVariantBaseMethod, variantWithInheritanceDerived.GetMethod("WhichMethod", null) }); yield return(new object[] { variantWithInheritanceDerived, iVariantMidMethod, variantWithInheritanceDerived.GetMethod("WhichMethod", null) }); yield return(new object[] { variantWithInheritanceDerived, iVariantDerivedMethod, variantWithInheritanceDerived.GetMethod("WhichMethod", null) }); yield return(new object[] { genericVariantWithInheritanceDerived.MakeInstantiatedType(@base), iVariantBaseMethod, genericVariantWithInheritanceDerived.MakeInstantiatedType(@base).GetMethod("WhichMethod", null) }); yield return(new object[] { genericVariantWithInheritanceDerived.MakeInstantiatedType(@base), iVariantMidMethod, genericVariantWithInheritanceDerived.MakeInstantiatedType(@base).GetMethod("WhichMethod", null) }); yield return(new object[] { genericVariantWithInheritanceDerived.MakeInstantiatedType(mid), iVariantMidMethod, genericVariantWithInheritanceDerived.MakeInstantiatedType(mid).GetMethod("WhichMethod", null) }); yield return(new object[] { genericVariantWithHiddenDerived.MakeInstantiatedType(@base), iVariantBaseMethod, genericVariantWithHiddenDerived.MakeInstantiatedType(@base).GetMethod("WhichMethod", null) }); yield return(new object[] { genericVariantWithHiddenDerived.MakeInstantiatedType(@base), iVariantMidMethod, genericVariantWithHiddenDerived.MakeInstantiatedType(@base).GetMethod("WhichMethod", null) }); yield return(new object[] { genericVariantWithHiddenDerived.MakeInstantiatedType(mid), iVariantMidMethod, genericVariantWithHiddenDerived.MakeInstantiatedType(mid).GetMethod("WhichMethod", null) }); yield return(new object[] { genericVariantWithHiddenDerived.MakeInstantiatedType(derived), iVariantMidMethod, genericVariantWithHiddenBase.GetMethod("WhichMethod", null) }); }