public void NestedInterfaceWithOverrides()
{
var generatedType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingMixinMembers), typeof(MixinWithAbstractMembers));
var overrideInterface = generatedType.GetNestedType("IOverriddenMethods");
Assert.That(overrideInterface, Is.Not.Null);
var method = overrideInterface.GetMethod("AbstractMethod");
Assert.That(method, Is.Not.Null);
Assert.That(method.ReturnType, Is.SameAs(typeof(string)));
var parameters = method.GetParameters();
Assert.That(parameters.Length, Is.EqualTo(1));
Assert.That(parameters[0].ParameterType, Is.SameAs(typeof(int)));
Assert.That(parameters[0].Name, Is.EqualTo("i"));
var propertyAccessor = overrideInterface.GetMethod("get_AbstractProperty");
Assert.That(propertyAccessor, Is.Not.Null);
var eventAccessor = overrideInterface.GetMethod("add_AbstractEvent");
Assert.That(eventAccessor, Is.Not.Null);
}
public void CheckMixinArray_MatchingMixins_NeedDerived()
{
Type concreteMixinType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingSpecificMixinMember), typeof(MixinWithVirtualMethod));
var initializer = CreateInitializer(typeof(ClassOverridingSpecificMixinMember), typeof(MixinWithVirtualMethod));
var mixin = Activator.CreateInstance(concreteMixinType);
initializer.CheckMixinArray(new[] { mixin });
}
public void CheckMixinArray_NonMatchingMixins_NeedDerived()
{
Type concreteMixinType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingSpecificMixinMember), typeof(MixinWithVirtualMethod));
MixinArrayInitializer initializer = CreateInitializer(typeof(ClassOverridingSpecificMixinMember), concreteMixinType);
initializer.CheckMixinArray(new object[] { new MixinWithVirtualMethod() });
}
public void GetMixinArray_WithFittingSuppliedForDerivedMixin()
{
var mixin1 = new MixinWithVirtualMethod();
var concreteMixinType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingSpecificMixinMember), typeof(MixinWithVirtualMethod));
MixinArrayInitializer initializer = CreateInitializer(typeof(ClassOverridingSpecificMixinMember), concreteMixinType);
initializer.CreateMixinArray(new object[] { mixin1 });
}
public void TypeImplementedOverrideInterfaces_OfMixinTypes()
{
var concreteType = CreateMixedType(typeof(ClassOverridingMixinMembers), typeof(MixinWithAbstractMembers));
var concreteMixinType = CodeGenerationTypeMother.GetGeneratedMixinTypeAndMetadata(
typeof(ClassOverridingMixinMembers),
typeof(MixinWithAbstractMembers));
Assert.That(concreteType.GetInterfaces(), Has.Member(concreteMixinType.GeneratedOverrideInterface));
}
public void GeneratedMixinTypeHasMixinTypeAttribute()
{
Type generatedType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingMixinMembers), typeof(MixinWithAbstractMembers));
Assert.That(generatedType.IsDefined(typeof(ConcreteMixinTypeAttribute), false), Is.True);
var attributes = (ConcreteMixinTypeAttribute[])generatedType.GetCustomAttributes(typeof(ConcreteMixinTypeAttribute), false);
Assert.That(attributes.Length, Is.EqualTo(1));
}
public void GetMixinArray_ForDerivedMixin()
{
Type concreteMixinType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingMixinMembers), typeof(MixinWithAbstractMembers));
MixinArrayInitializer initializer = CreateInitializer(typeof(ClassOverridingMixinMembers), concreteMixinType);
var mixinArray = initializer.CreateMixinArray(null);
Assert.That(mixinArray.Length, Is.EqualTo(1));
Assert.That(mixinArray[0], Is.InstanceOf(typeof(MixinWithAbstractMembers)));
Assert.That(mixinArray[0].GetType(), Is.Not.SameAs(typeof(MixinWithAbstractMembers)));
}
public void GetMixinArray_WithFittingDerivedSuppliedForDerivedMixin()
{
using (MixinConfiguration.BuildNew().ForClass <ClassOverridingSpecificMixinMember> ().AddMixin <MixinWithVirtualMethod> ().EnterScope())
{
var concreteMixinType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingSpecificMixinMember), typeof(MixinWithVirtualMethod));
var initializer = CreateInitializer(typeof(ClassOverridingSpecificMixinMember), concreteMixinType);
var mixin1 = Activator.CreateInstance(concreteMixinType);
var mixins = initializer.CreateMixinArray(new[] { mixin1 });
Assert.That(mixins, Is.EqualTo(new[] { mixin1 }));
}
}
public void IdentifierMember_HoldsIdentifier()
{
var requestingClass = MixinConfiguration.ActiveConfiguration.GetContext(typeof(ClassOverridingMixinMembers));
MixinDefinition mixinDefinition = DefinitionObjectMother.GetTargetClassDefinition(requestingClass).Mixins[typeof(MixinWithAbstractMembers)];
Assert.That(mixinDefinition, Is.Not.Null);
Type generatedType = CodeGenerationTypeMother.GetGeneratedMixinType(requestingClass, typeof(MixinWithAbstractMembers));
var identifier = generatedType.GetField("__identifier").GetValue(null);
Assert.That(identifier, Is.EqualTo(mixinDefinition.GetConcreteMixinTypeIdentifier()));
}
public void MixinTypeAttribute_CanBeUsedToGetIdentifier()
{
var requestingClass = MixinConfiguration.ActiveConfiguration.GetContext(typeof(ClassOverridingMixinMembers));
MixinDefinition mixinDefinition = DefinitionObjectMother.GetTargetClassDefinition(requestingClass).Mixins[typeof(MixinWithAbstractMembers)];
Assert.That(mixinDefinition, Is.Not.Null);
Type generatedType = CodeGenerationTypeMother.GetGeneratedMixinType(requestingClass, typeof(MixinWithAbstractMembers));
Assert.That(generatedType.IsDefined(typeof(ConcreteMixinTypeAttribute), false), Is.True);
var attributes = (ConcreteMixinTypeAttribute[])generatedType.GetCustomAttributes(typeof(ConcreteMixinTypeAttribute), false);
Assert.That(attributes[0].GetIdentifier(), Is.EqualTo(mixinDefinition.GetConcreteMixinTypeIdentifier()));
}
public void TypeImplementedOverrideInterfaces_OfMixinTypes_ProtectedOverriders()
{
var concreteType = CreateMixedType(typeof(ClassOverridingMixinMembersProtected), typeof(MixinWithAbstractMembers));
var concreteMixinType = CodeGenerationTypeMother.GetGeneratedMixinTypeAndMetadata(
typeof(ClassOverridingMixinMembersProtected),
typeof(MixinWithAbstractMembers));
Assert.That(concreteType.GetInterfaces(), Has.Member(concreteMixinType.GeneratedOverrideInterface));
var abstractMethodWrapperName =
MethodOverrideUtility.GetNameForExplicitOverride(concreteMixinType.GeneratedOverrideInterface.GetMethod("AbstractMethod"));
var explicitInterfaceMember = concreteType.GetMethod(abstractMethodWrapperName, BindingFlags.NonPublic | BindingFlags.Instance);
Assert.That(explicitInterfaceMember, Is.Not.Null);
var abstractGetterWrapperName =
MethodOverrideUtility.GetNameForExplicitOverride(concreteMixinType.GeneratedOverrideInterface.GetMethod("get_AbstractProperty"));
var explicitInterfacePropertyGetter = concreteType.GetMethod(
abstractGetterWrapperName,
BindingFlags.NonPublic | BindingFlags.Instance);
Assert.That(explicitInterfacePropertyGetter, Is.Not.Null);
}
public void GeneratedTypeImplementsMarkerInterface()
{
Type generatedType = CodeGenerationTypeMother.GetGeneratedMixinType(typeof(ClassOverridingMixinMembers), typeof(MixinWithAbstractMembers));
Assert.That(typeof(IGeneratedMixinType).IsAssignableFrom(generatedType), Is.True);
}
