public void IndexerTests()
{
var assembly = AssemblyData.FromAssembly(typeof(AddedAbstractMemberTests).Assembly);
var IndexerNonVirtual = TypeDefinitionData.FromType(typeof(IndexerNonVirtual));
var IndexerVirtual = TypeDefinitionData.FromType(typeof(IndexerVirtual));
var IndexerAbstract = TypeDefinitionData.FromType(typeof(IndexerAbstract));
var breakingChanges = MetadataComparer.CompareTypes(IndexerVirtual, IndexerNonVirtual);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when a virtual member changes to non-virtual.");
Assert.AreEqual(BreakingChangeKind.ChangedMemberToNonVirtual, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(IndexerVirtual.GetMember("Item"), breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(IndexerNonVirtual.GetMember("Item"), breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(IndexerAbstract, IndexerNonVirtual);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when an abstract member changes to non-virtual.");
Assert.AreEqual(BreakingChangeKind.ChangedMemberToNonVirtual, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(IndexerAbstract.GetMember("Item"), breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(IndexerNonVirtual.GetMember("Item"), breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(IndexerNonVirtual, IndexerVirtual);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when a non-virtual member changes to virtual.");
}
public void TypeDefinitionDataIsExtensionsClassTest()
{
var assembly = AssemblyData.FromAssembly(typeof(TypeDefinitionDataTests).Assembly);
Assert.IsFalse(TypeDefinitionData.FromType(typeof(StaticClass)).IsExtensionsClass, "The IsExtensionsClass value is incorrect.");
Assert.IsTrue(TypeDefinitionData.FromType(typeof(ExtensionsClass)).IsExtensionsClass, "The IsExtensionsClass value is incorrect.");
}
internal AddedBaseInterface(TypeDefinitionData oldType, TypeDefinitionData newType, DeclaringTypeData newInterfaceType)
: base(oldType, newType, newInterfaceType, BreakingChangeKind.AddedBaseInterface)
{
OldType = oldType;
NewType = newType;
NewInterfaceType = newInterfaceType;
}
internal RemovedImplementedInterface(TypeDefinitionData oldType, TypeDefinitionData newType, DeclaringTypeData oldInterfaceType)
: base(oldType, newType, oldInterfaceType, BreakingChangeKind.RemovedImplementedInterface)
{
OldType = oldType;
NewType = newType;
OldInterfaceType = oldInterfaceType;
}
public void IndexerDataMemberFlagsTest()
{
var t = typeof(OverloadedMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var members = typeData.GetMembers("Item");
Assert.AreEqual(9, members.Count, "Incorrect number of indexers");
var indexerData = (IndexerData)members[0];
Assert.AreEqual(MemberFlags.None, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[1];
Assert.AreEqual(MemberFlags.Abstract, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[2];
Assert.AreEqual(MemberFlags.Virtual, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[3];
Assert.AreEqual(MemberFlags.Override, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[4];
Assert.AreEqual(MemberFlags.Override | MemberFlags.Sealed, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[5];
Assert.AreEqual(MemberFlags.Override | MemberFlags.Abstract, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[6];
Assert.AreEqual(MemberFlags.Override, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[7];
Assert.AreEqual(MemberFlags.Override | MemberFlags.Sealed, indexerData.MemberFlags, "The Flags value of the member is wrong.");
indexerData = (IndexerData)members[8];
Assert.AreEqual(MemberFlags.Override | MemberFlags.Abstract, indexerData.MemberFlags, "The Flags value of the member is wrong.");
}
public void TypeTests()
{
var assembly = AssemblyData.FromAssembly(typeof(ChangedAccessibilityFromPublicToProtectedTests).Assembly);
var derivedFromBase = TypeDefinitionData.FromType(typeof(DerivedFromBase));
var derivedFromSpecializedBase = TypeDefinitionData.FromType(typeof(DerivedFromSpecializedBase));
var derivedFromOtherBase = TypeDefinitionData.FromType(typeof(DerivedFromOtherBase));
var breakingChanges = MetadataComparer.CompareTypes(derivedFromBase, derivedFromSpecializedBase);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when the new type derives from a more specialized base class.");
breakingChanges = MetadataComparer.CompareTypes(derivedFromBase, derivedFromOtherBase);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when the new type derives from a different base class.");
Assert.AreEqual(BreakingChangeKind.IncompatibleClassHierarchy, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(derivedFromBase, breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(derivedFromOtherBase, breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(derivedFromSpecializedBase, derivedFromBase);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when the new type derives from a less specialized base class.");
Assert.AreEqual(BreakingChangeKind.IncompatibleClassHierarchy, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(derivedFromSpecializedBase, breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(derivedFromBase, breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(derivedFromSpecializedBase, derivedFromOtherBase);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when the new type derives from a different base class.");
Assert.AreEqual(BreakingChangeKind.IncompatibleClassHierarchy, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(derivedFromSpecializedBase, breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(derivedFromOtherBase, breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
}
public void TypeTests()
{
var assembly = AssemblyData.FromAssembly(typeof(ChangedClassToStaticTests).Assembly);
var Class = TypeDefinitionData.FromType(typeof(Class));
var ClassWithInternalConstructor = TypeDefinitionData.FromType(typeof(ClassWithInternalConstructor));
var ClassWithProtectedConstructor = TypeDefinitionData.FromType(typeof(ClassWithProtectedConstructor));
var StaticClass = TypeDefinitionData.FromType(typeof(StaticClass));
var breakingChanges = MetadataComparer.CompareTypes(Class, StaticClass).Where(b => b.BreakingChangeKind == BreakingChangeKind.ChangedClassToStatic).ToList();
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when a class is made static.");
Assert.AreEqual(BreakingChangeKind.ChangedClassToStatic, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(Class, breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(StaticClass, breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(ClassWithInternalConstructor, StaticClass);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when a class with no public constructors is made abstract.");
breakingChanges = MetadataComparer.CompareTypes(ClassWithProtectedConstructor, StaticClass).Where(b => b.BreakingChangeKind == BreakingChangeKind.ChangedClassToStatic).ToList();
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when a class is made static.");
Assert.AreEqual(BreakingChangeKind.ChangedClassToStatic, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(ClassWithProtectedConstructor, breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(StaticClass, breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
}
public void TypeDefinitionDataMembersInStructTest()
{
var t = typeof(TestStructDefinition);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
Assert.IsNotNull(typeData, "Unable to create a TypeDefinitionData instance from the TestClassDefinition type.");
TestUtilities.VerifyMember <ConstantData>(typeData, "Constant");
TestUtilities.VerifyInstanceAndStaticMember <FieldData>(typeData, "Field");
TestUtilities.VerifyInstanceAndStaticMember <FieldData>(typeData, "FieldReadOnly");
var members = typeData.GetMembers(".ctor");
Assert.AreEqual(1, members.Count, "Incorrect number of constructors returned.");
Assert.AreEqual(1, ((ConstructorData)members[0]).Parameters.Count, "The public constructor should have been returned.");
TestUtilities.VerifyInstanceAndStaticMember <EventData>(typeData, "Event");
TestUtilities.VerifyInstanceAndStaticMember <EventData>(typeData, "EventCustom");
members = typeData.GetMembers("Item");
Assert.AreEqual(1, members.Count, "Incorrect number of indexers returned.");
Assert.AreEqual(1, ((IndexerData)members[0]).Parameters.Count, "The public indexer should have been returned.");
TestUtilities.VerifyInstanceAndStaticMember <MethodData>(typeData, "Method");
var member = (OperatorData)typeData.GetMember("op_Addition");
Assert.IsNotNull(member, "OperatorData instances should be returned.");
TestUtilities.VerifyInstanceAndStaticMember <PropertyData>(typeData, "Property");
TestUtilities.VerifyMember <TypeDefinitionData>(typeData, "NestedStruct");
}
private TypeData ReadTypeDataBase(AssemblyData assemblyData)
{
var typeId = _reader.ReadUInt32();
var name = _reader.ReadString();
var accessibility = (Accessibility)_reader.ReadByte();
var memberFlags = (MemberFlags)_reader.ReadByte();
var typeKind = (TypeKind)_reader.ReadByte();
var delegateReturnTypeIsDynamic = _reader.ReadBoolean();
TypeData type;
var isTypeData = _reader.ReadBoolean();
if (isTypeData)
{
var typeFlags = (TypeDefinitionFlags)_reader.ReadByte();
var hasFullName = _reader.ReadBoolean();
var fullName = hasFullName ? _reader.ReadString() : null;
type = new TypeDefinitionData(name, accessibility, memberFlags, typeKind, assemblyData, fullName, typeFlags, delegateReturnTypeIsDynamic);
}
else
{
var genericParameterAttributes = (GenericParameterAttributes)_reader.ReadInt32();
var genericParameterPosition = (int)_reader.ReadUInt16();
type = new GenericTypeParameterData(name, accessibility, memberFlags, typeKind, assemblyData, genericParameterAttributes, genericParameterPosition);
}
_typeTable.Add(typeId, type);
return(type);
}
public void GenericParameterRenameTest()
{
var assembly = AssemblyData.FromAssembly(typeof(MiscellaneousTests).Assembly);
var typeData1 = TypeDefinitionData.FromType(typeof(GenericParameter1 <>));
var typeData2 = TypeDefinitionData.FromType(typeof(GenericParameter2 <>));
var typeData3 = TypeDefinitionData.FromType(typeof(GenericParameter3 <,>));
var typeData4 = TypeDefinitionData.FromType(typeof(GenericParameter4 <,>));
var breakingChanges = MetadataComparer.CompareTypes(typeData1, typeData2);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes for renaming a class's generic type parameter.");
breakingChanges = MetadataComparer.CompareTypes(typeData3, typeData4);
Assert.AreEqual(1, breakingChanges.Count, "There should be a breaking changes for using a different generic type parameter position as a return type.");
Assert.AreEqual(BreakingChangeKind.ChangedMemberType, breakingChanges[0].BreakingChangeKind, "There should be a breaking changes for using a different generic type parameter position as a return type.");
typeData1 = TypeDefinitionData.FromType(typeof(GenericMethodParameter1));
typeData2 = TypeDefinitionData.FromType(typeof(GenericMethodParameter2));
typeData3 = TypeDefinitionData.FromType(typeof(GenericMethodParameter3));
typeData4 = TypeDefinitionData.FromType(typeof(GenericMethodParameter4));
breakingChanges = MetadataComparer.CompareTypes(typeData1, typeData2);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes for renaming a class's generic type parameter.");
breakingChanges = MetadataComparer.CompareTypes(typeData3, typeData4);
Assert.AreEqual(1, breakingChanges.Count, "There should be a breaking changes for using a different generic type parameter position as a return type.");
Assert.AreEqual(BreakingChangeKind.ChangedMemberType, breakingChanges[0].BreakingChangeKind, "There should be a breaking changes for using a different generic type parameter position as a return type.");
}
public void EventDataMemberFlagsTest()
{
var t = typeof(OverloadedMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var eventData = (EventData)typeData.GetMember("EventInstance");
Assert.AreEqual(MemberFlags.None, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventStatic");
Assert.AreEqual(MemberFlags.Static, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceAbstract");
Assert.AreEqual(MemberFlags.Abstract, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceVirtual");
Assert.AreEqual(MemberFlags.Virtual, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceOverrideAbstract");
Assert.AreEqual(MemberFlags.Override, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceOverrideAbstractSealed");
Assert.AreEqual(MemberFlags.Override | MemberFlags.Sealed, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceOverrideAbstractAbstract");
Assert.AreEqual(MemberFlags.Override | MemberFlags.Abstract, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceOverrideVirtual");
Assert.AreEqual(MemberFlags.Override, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceOverrideVirtualSealed");
Assert.AreEqual(MemberFlags.Override | MemberFlags.Sealed, eventData.MemberFlags, "The Flags value of the member is wrong.");
eventData = (EventData)typeData.GetMember("EventInstanceOverrideVirtualAbstract");
Assert.AreEqual(MemberFlags.Override | MemberFlags.Abstract, eventData.MemberFlags, "The Flags value of the member is wrong.");
}
public void IndexerTests()
{
var assembly = AssemblyData.FromAssembly(typeof(RemovedOverrideOfAbstractMemberTests).Assembly);
var IndexerVirtual = TypeDefinitionData.FromType(typeof(IndexerVirtual));
var IndexerAbstract = TypeDefinitionData.FromType(typeof(IndexerAbstract));
var IndexerVirtualOverride = TypeDefinitionData.FromType(typeof(IndexerVirtualOverride));
var IndexerAbstractOverride = TypeDefinitionData.FromType(typeof(IndexerAbstractOverride));
var IndexerVirtualOverrideInternalConstructor = TypeDefinitionData.FromType(typeof(IndexerVirtualOverrideInternalConstructor));
var IndexerAbstractOverrideInternalConstructor = TypeDefinitionData.FromType(typeof(IndexerAbstractOverrideInternalConstructor));
var IndexerVirtualNoOverride = TypeDefinitionData.FromType(typeof(IndexerVirtualNoOverride));
var IndexerAbstractNoOverride = TypeDefinitionData.FromType(typeof(IndexerAbstractNoOverride));
var breakingChanges = MetadataComparer.CompareTypes(IndexerVirtualOverride, IndexerVirtualNoOverride);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when an override of a virtual member is removed.");
breakingChanges = MetadataComparer.CompareTypes(IndexerVirtualOverrideInternalConstructor, IndexerVirtualNoOverride);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when an override of a virtual member is removed and there are no externally visible constructors.");
breakingChanges = MetadataComparer.CompareTypes(IndexerAbstractOverride, IndexerAbstractNoOverride);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when an override of an abstract member is removed.");
Assert.AreEqual(BreakingChangeKind.RemovedOverrideOfAbstractMember, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(IndexerAbstractOverride.GetMember("Item"), breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.IsNull(breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.AreEqual(IndexerAbstractNoOverride, breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(IndexerAbstractOverrideInternalConstructor, IndexerAbstractNoOverride);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when an override of an abstract member is removed and there are no externally visible constructors.");
}
public void ConstructorTests()
{
var assembly = AssemblyData.FromAssembly(typeof(ChangedAccessibilityFromPublicToProtectedTests).Assembly);
var publicConstructor = TypeDefinitionData.FromType(typeof(PublicConstructor));
var protectedConstructor = TypeDefinitionData.FromType(typeof(ProtectedConstructor));
var protectedInternalConstructor = TypeDefinitionData.FromType(typeof(ProtectedInternalConstructor));
var breakingChanges = MetadataComparer.CompareTypes(publicConstructor, protectedConstructor);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when a constant is changed from public to protected");
Assert.AreEqual(BreakingChangeKind.ChangedAccessibilityFromPublicToProtected, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(TypeDefinitionData.FromType(typeof(PublicConstructor)).GetMembers(".ctor")[0], breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(TypeDefinitionData.FromType(typeof(ProtectedConstructor)).GetMembers(".ctor")[0], breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(publicConstructor, protectedInternalConstructor);
Assert.AreEqual(1, breakingChanges.Count, "There should be one breaking change when a constructor is changed from public to protected internal");
Assert.AreEqual(BreakingChangeKind.ChangedAccessibilityFromPublicToProtected, breakingChanges[0].BreakingChangeKind, "The BreakingChangeKind is incorrect.");
Assert.AreEqual(TypeDefinitionData.FromType(typeof(PublicConstructor)).GetMembers(".ctor")[0], breakingChanges[0].OldItem, "The OldItem is incorrect.");
Assert.AreEqual(TypeDefinitionData.FromType(typeof(ProtectedInternalConstructor)).GetMembers(".ctor")[0], breakingChanges[0].NewItem, "The NewItem is incorrect.");
Assert.IsNull(breakingChanges[0].AssociatedData, "The AssociatedData is incorrect.");
breakingChanges = MetadataComparer.CompareTypes(protectedConstructor, publicConstructor);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when a constructor is changed from protected to public");
breakingChanges = MetadataComparer.CompareTypes(protectedConstructor, protectedInternalConstructor);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when a constructor is changed from protected to protected internal");
breakingChanges = MetadataComparer.CompareTypes(protectedInternalConstructor, publicConstructor);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when a constructor is changed from protected internal to public");
breakingChanges = MetadataComparer.CompareTypes(protectedInternalConstructor, protectedConstructor);
Assert.AreEqual(0, breakingChanges.Count, "There should be no breaking changes when a constructor is changed from protected internal to protected");
}
public void GenericTypeParameterDataContraintsTest()
{
var t = typeof(TestClassDefinition <, , , ,>);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var testClassDefinitionData = TypeDefinitionData.FromType(t);
var equatableInterfaceData = ConstructedGenericTypeData.FromType <IEquatable <TestClassDefinition> >();
var testInterfaceDefinitionData = TypeDefinitionData.FromType <TestInterfaceDefinition>();
var valueTypeData = TypeDefinitionData.FromType <ValueType>();
var p1 = testClassDefinitionData.GenericParameters[0];
Assert.AreEqual(0, p1.Constraints.Count, "The number of Constraints on the genertic type parameter is incorrect.");
var p2 = testClassDefinitionData.GenericParameters[1];
Assert.AreEqual(2, p2.Constraints.Count, "The number of Constraints on the genertic type parameter is incorrect.");
// Note: these may need to be reversed
Assert.AreEqual(equatableInterfaceData, p2.Constraints[0], "The reported type is not correct.");
Assert.AreEqual(testInterfaceDefinitionData, p2.Constraints[1], "The reported type is not correct.");
var p3 = testClassDefinitionData.GenericParameters[2];
Assert.AreEqual(0, p3.Constraints.Count, "The number of Constraints on the genertic type parameter is incorrect.");
var p4 = testClassDefinitionData.GenericParameters[3];
Assert.AreEqual(1, p4.Constraints.Count, "The number of Constraints on the genertic type parameter is incorrect.");
Assert.AreEqual(valueTypeData, p4.Constraints[0], "The reported type is not correct.");
var p5 = testClassDefinitionData.GenericParameters[4];
Assert.AreEqual(0, p5.Constraints.Count, "The number of Constraints on the genertic type parameter is incorrect.");
}
public void OperatorDataAllOperatorsTest()
{
var t = typeof(VariousMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
Assert.IsNotNull(typeData.GetMember("op_Implicit"));
Assert.IsNotNull(typeData.GetMember("op_Explicit"));
Assert.IsNotNull(typeData.GetMember("op_Addition"));
Assert.IsNotNull(typeData.GetMember("op_Subtraction"));
Assert.IsNotNull(typeData.GetMember("op_Multiply"));
Assert.IsNotNull(typeData.GetMember("op_Division"));
Assert.IsNotNull(typeData.GetMember("op_Modulus"));
Assert.IsNotNull(typeData.GetMember("op_ExclusiveOr"));
Assert.IsNotNull(typeData.GetMember("op_BitwiseAnd"));
Assert.IsNotNull(typeData.GetMember("op_BitwiseOr"));
Assert.IsNotNull(typeData.GetMember("op_LeftShift"));
Assert.IsNotNull(typeData.GetMember("op_RightShift"));
Assert.IsNotNull(typeData.GetMember("op_Equality"));
Assert.IsNotNull(typeData.GetMember("op_GreaterThan"));
Assert.IsNotNull(typeData.GetMember("op_LessThan"));
Assert.IsNotNull(typeData.GetMember("op_Inequality"));
Assert.IsNotNull(typeData.GetMember("op_GreaterThanOrEqual"));
Assert.IsNotNull(typeData.GetMember("op_LessThanOrEqual"));
Assert.IsNotNull(typeData.GetMember("op_Decrement"));
Assert.IsNotNull(typeData.GetMember("op_Increment"));
Assert.IsNotNull(typeData.GetMember("op_UnaryNegation"));
Assert.IsNotNull(typeData.GetMember("op_UnaryPlus"));
Assert.IsNotNull(typeData.GetMember("op_OnesComplement"));
Assert.IsNotNull(typeData.GetMember("op_LogicalNot"));
Assert.IsNotNull(typeData.GetMember("op_True"));
Assert.IsNotNull(typeData.GetMember("op_False"));
}
public void CustomConstructionTest()
{
var type = TypeDefinitionData.FromType(typeof(List <>));
var addMethod = type.GetMethod("Add");
Assert.AreEqual("T", addMethod.Parameters[0].Type.Name);
var constructedType = type.GetConstructedGenericTypeData(new[] { TypeData.FromType <TestTypeArgument>() });
addMethod = constructedType.GetMethod("Add");
Assert.AreEqual("TestTypeArgument", addMethod.Parameters[0].Type.Name);
type = TypeDefinitionData.FromType(typeof(TestGenericTypeDefinition <>));
constructedType = type.GetConstructedGenericTypeData(new[] { TypeData.FromType <TestTypeArgument>() });
var constructor = (ConstructorData)constructedType.GetMember(".ctor");
Assert.AreEqual("TestTypeArgument?", constructor.Parameters[0].Type.GetDisplayName(fullyQualify: false));
var _event = (EventData)constructedType.GetMember("Event");
Assert.AreEqual("EventHandler<TestTypeArgument>", _event.Type.GetDisplayName(fullyQualify: false));
var field = (FieldData)constructedType.GetMember("Field");
Assert.AreEqual("TestTypeArgument[]", field.Type.GetDisplayName(fullyQualify: false));
var indexer = (IndexerData)constructedType.GetMember("Item");
Assert.AreEqual("IList<TestTypeArgument>", indexer.Type.GetDisplayName(fullyQualify: false));
Assert.AreEqual("TestTypeArgument[]", indexer.Parameters[0].Type.GetDisplayName(fullyQualify: false));
var method = (MethodData)constructedType.GetMember("Method");
Assert.AreEqual("TestTypeArgument?", method.Type.GetDisplayName(fullyQualify: false));
Assert.AreEqual("TestTypeArgument", method.Parameters[0].Type.GetDisplayName(fullyQualify: false));
Assert.AreEqual("U", method.Parameters[1].Type.GetDisplayName(fullyQualify: false));
Assert.AreEqual("Dictionary<TestTypeArgument[], U[]>", method.Parameters[2].Type.GetDisplayName(fullyQualify: false));
var _operator = (OperatorData)constructedType.GetMember("op_Addition");
Assert.AreEqual("KeyValuePair<TestTypeArgument, object>", _operator.Type.GetDisplayName(fullyQualify: false));
Assert.AreEqual("TestGenericTypeDefinition<TestTypeArgument>", _operator.Parameters[0].Type.GetDisplayName(fullyQualify: false));
Assert.AreEqual("TestTypeArgument", _operator.Parameters[1].Type.GetDisplayName(fullyQualify: false));
var property = (PropertyData)constructedType.GetMember("Property");
Assert.AreEqual("IComparer<TestTypeArgument>", property.Type.GetDisplayName(fullyQualify: false));
var nestedType = (ConstructedGenericTypeData)constructedType.GetMember("NestedType`1");
Assert.IsNull(nestedType);
type = TypeDefinitionData.FromType(typeof(TestGenericTypeDefinition <> .NestedType <>));
constructedType = type.GetConstructedGenericTypeData(new[] { TypeData.FromType <TestTypeArgument>(), TypeData.FromType <double>() });
Assert.AreEqual("NestedType<double>", constructedType.GetDisplayName(fullyQualify: false));
Assert.AreEqual("BreakingChangesDetector.UnitTests.MetadataTypesTests.ConstructedGenericTypeDataTests.TestGenericTypeDefinition<TestTypeArgument>.NestedType<double>", constructedType.GetDisplayName());
Assert.AreEqual("Tuple<int, TestTypeArgument[], double>", constructedType.BaseType.GetDisplayName(fullyQualify: false));
type = TypeDefinitionData.FromType(typeof(TestGenericTypeDefinition <> .NestedType <> .FurtherNestedType <>));
constructedType = type.GetConstructedGenericTypeData(new[] { TypeData.FromType <int>(), TypeData.FromType <TestTypeArgument>(), TypeData.FromType <double>() });
Assert.AreEqual("FurtherNestedType<double>", constructedType.GetDisplayName(fullyQualify: false));
Assert.AreEqual("BreakingChangesDetector.UnitTests.MetadataTypesTests.ConstructedGenericTypeDataTests.TestGenericTypeDefinition<int>.NestedType<TestTypeArgument>.FurtherNestedType<double>", constructedType.GetDisplayName());
Assert.AreEqual("Dictionary<int, Tuple<TestTypeArgument, double>>", constructedType.BaseType.GetDisplayName(fullyQualify: false));
}
public void TypeDefinitionDataNameTest()
{
var t = typeof(TestClassDefinition);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
Assert.AreEqual(t.Name, typeData.Name, "The Name is not assigned correctly.");
}
public void TypeDefinitionDataAssemblyTest()
{
var t = typeof(TestClassDefinition);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
Assert.AreEqual(assembly, typeData.AssemblyData, "The Assembly reference is not assigned correctly.");
}
public void TypeDefinitionDataAccessibilityTest()
{
var t = typeof(TestClassDefinition);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
TestUtilities.VerifyAccessibility(typeData, "NestedStruct");
}
public void EventDataAccessibilityTest()
{
var t = typeof(TestClassDefinition);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
TestUtilities.VerifyAccessibility(typeData, "EventInstance");
}
public void OperatorDataAccessibilityTest()
{
var t = typeof(VariousMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var member = typeData.GetMember("op_Addition");
Assert.AreEqual(MemberAccessibility.Public, member.Accessibility, "Incorrect Accessibility");
}
public void OperatorDataParametersTest()
{
var t = typeof(VariousMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var method = (OperatorData)typeData.GetMember("op_Addition");
Assert.AreEqual(2, method.Parameters.Count, "The public method has the wrong number of parameters.");
}
public void OperatorDataNameTest()
{
var t = typeof(VariousMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var method = typeData.GetMember("op_Addition");
Assert.AreEqual("op_Addition", method.Name, "The Name of the member is incorrect.");
}
public void EventDataNameTest()
{
var t = typeof(TestClassDefinition);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var eventData = typeData.GetMember("EventInstance");
Assert.AreEqual("EventInstance", eventData.Name, "The Name of the member is incorrect.");
}
public void NullableIntDefaultValueTests()
{
var assembly = AssemblyData.FromAssembly(typeof(DefaultValueInfoTests).Assembly);
var typeData = TypeDefinitionData.FromType(typeof(MethodWithDefaultValues));
var method = typeData.GetMethod("MethodWithInts");
Assert.AreEqual(null, method.Parameters[0].DefaultValue);
Assert.AreEqual(0, method.Parameters[1].DefaultValue);
}
public void NullableEnumDefaultValueTests()
{
var assembly = AssemblyData.FromAssembly(typeof(DefaultValueInfoTests).Assembly);
var typeData = TypeDefinitionData.FromType(typeof(MethodWithDefaultValues));
var method = typeData.GetMethod("MethodWithEnums");
Assert.AreEqual(null, method.Parameters[0].DefaultValue);
Assert.AreEqual((ulong)DateTimeKind.Local, method.Parameters[1].DefaultValue);
}
public void OperatorDataDeclaringTypeTest()
{
var t = typeof(VariousMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var method = typeData.GetMember("op_Addition");
Assert.AreEqual(typeData, method.DeclaringType, "The DeclaringType of a member should be the type in which it is defined.");
}
public void EventDataDeclaringTypeTest()
{
var t = typeof(TestClassDefinition);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var eventData = typeData.GetMember("EventInstance");
Assert.AreEqual(typeData, eventData.DeclaringType, "The DeclaringType of a member should be the type in which it is defined.");
}
public void PropertyDataDeclaringTypeTest()
{
var t = typeof(VariousMemberFeatures);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var member = (PropertyData)typeData.GetMember("PropertyReadOnly");
Assert.AreEqual(typeData, member.DeclaringType, "The DeclaringType of a member should be the type in which it is defined.");
}
public void ProtectedMembersInSealedClassesNotStoredTest()
{
var t = typeof(SealedClass);
var assembly = AssemblyData.FromAssembly(t.Assembly);
var typeData = TypeDefinitionData.FromType(t);
var members = typeData.GetMembers("MethodVirtual");
Assert.IsTrue(members == null || members.Count == 0, "Protected members of sealed classes should never be considered for breaking changes.");
}
