public void GetOverrides_WithOverrides_ForMemberInBaseClass()
{
var targetType = typeof(BaseMemberOverrideTestClass.Target);
var mixinConfiguration =
MixinConfiguration.BuildNew()
.ForClass <BaseMemberOverrideTestClass.Target> ().AddMixin <BaseMemberOverrideTestClass.Mixin1> ()
.BuildConfiguration();
var targetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(targetType, mixinConfiguration));
var involvedType = new InvolvedType(targetType)
{
TargetClassDefinition = targetClassDefinition,
ClassContext = new ReflectedObject(mixinConfiguration.ClassContexts.First())
};
var reportGenerator = CreateMemberReportGenerator(targetType, involvedType);
//var memberInfo = targetType.GetMember ("OverriddenMethod")[0];
var output = reportGenerator.GenerateXml();
var expectedOutput =
new XElement(
"Overrides",
new XElement(
"Mixin-Reference",
new XAttribute("ref", 0),
new XAttribute("instance-name", "BaseMemberOverrideTestClass+Mixin1")
));
Assert.That(output.XPathSelectElement("Member[@name='OverriddenMethod']").Element("Overrides").ToString(), Is.EqualTo(expectedOutput.ToString()));
}
public void GenerateXml_InterfaceDynamicallyImplemented()
{
var targetType = new InvolvedType(typeof(TargetClass3));
var mixinConfiguration = MixinConfiguration.BuildNew().ForClass <TargetClass3> ().AddMixin <Mixin4> ().BuildConfiguration();
targetType.ClassContext = new ReflectedObject(mixinConfiguration.ClassContexts.First());
targetType.TargetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(targetType.Type, mixinConfiguration));
var mixinContext = targetType.ClassContext.GetProperty("Mixins").First();
var mixinDefinition = targetType.TargetClassDefinition.CallMethod("GetMixinByConfiguredType", mixinContext.GetProperty("MixinType").To <Type> ());
var assemblyIdentifierGenerator = new IdentifierGenerator <Assembly> ();
var output = new TargetCallDependenciesReportGenerator(mixinDefinition, assemblyIdentifierGenerator,
_remotionReflector, _outputFormatter).GenerateXml();
var expectedOutput = new XElement("TargetCallDependencies",
new XElement("Dependency",
new XAttribute("assembly-ref", "0"),
new XAttribute("namespace", "System"),
new XAttribute("name", "IDisposable"),
new XAttribute("is-interface", true),
new XAttribute("is-implemented-by-target", false),
new XAttribute("is-added-by-mixin", false),
new XAttribute("is-implemented-dynamically", true)));
XElementComparisonHelper.Compare(output, expectedOutput);
}
private ReflectedObject GetAttributeIntroductions(
InvolvedType targetType, Type mixinType, MixinConfiguration mixinConfiguration)
{
var targetClassDefinition = TargetClassDefinitionUtility.GetConfiguration(targetType.Type, mixinConfiguration);
return(new ReflectedObject(targetClassDefinition.GetMixinByConfiguredType(mixinType).AttributeIntroductions));
}
public void GenerateXml_TargetClassWithOverriddenBaseClassMember()
{
var type = typeof(InheritatedTargetClass);
var mixinConfiguration =
MixinConfiguration.BuildNew().ForClass <InheritatedTargetClass> ().AddMixin <MixinOverridesTargetClassMember> ().BuildConfiguration();
var targetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(type, mixinConfiguration));
var involvedType = new InvolvedType(type)
{
TargetClassDefinition = targetClassDefinition
};
var reportGenerator = CreateMemberReportGenerator(type, involvedType);
var output = reportGenerator.GenerateXml();
var expectedOutput = new XElement(
"Members",
new XElement(
"Member",
new XAttribute("id", "0"),
new XAttribute("type", MemberTypes.Constructor),
new XAttribute("name", ".ctor"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("", "public"),
_outputFormatter.CreateConstructorMarkup("InheritatedTargetClass", new ParameterInfo[0])
),
new XElement(
"Member",
new XAttribute("id", "1"),
new XAttribute("type", MemberTypes.Method),
new XAttribute("name", "MyBaseClassMethod"),
new XAttribute("is-declared-by-this-class", false),
_outputFormatter.CreateModifierMarkup("", "public virtual"),
_outputFormatter.CreateMethodMarkup("MyBaseClassMethod", typeof(void), new ParameterInfo[0]),
GenerateOverrides("Mixin-Reference", "0", "MixinOverridesTargetClassMember")
),
new XElement(
"Member",
new XAttribute("id", "2"),
new XAttribute("type", MemberTypes.Method),
new XAttribute("name", "MyNewMethod"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("", "public virtual"),
_outputFormatter.CreateMethodMarkup("MyNewMethod", typeof(void), new ParameterInfo[0])
),
new XElement(
"Member",
new XAttribute("id", "3"),
new XAttribute("type", MemberTypes.Method),
new XAttribute("name", "MyNonRelevantBaseClassMethod"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("", "public override"),
_outputFormatter.CreateMethodMarkup("MyNonRelevantBaseClassMethod", typeof(void), new ParameterInfo[0]),
GenerateOverrides("Mixin-Reference", "0", "MixinOverridesTargetClassMember")
)
);
XElementComparisonHelper.Compare(output, expectedOutput);
}
public void SetUp()
{
_remotionReflector = new Reflectors.OldMixinDependenciesReflector();
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass <TargetClass1> ()
.AddMixin <Mixin1> ()
.BuildConfiguration();
_targetClassDefinition = TargetClassDefinitionUtility.GetConfiguration(typeof(TargetClass1), mixinConfiguration);
_mixinDefinition = _targetClassDefinition.GetMixinByConfiguredType(typeof(Mixin1));
}
public void SimpleOverrideByTarget()
{
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass(typeof(TargetOverrideMixin)).AddMixin(typeof(TemplateMixin))
.BuildConfiguration();
var targetClassDefiniton = TargetClassDefinitionUtility.GetConfiguration(typeof(TargetOverrideMixin), mixinConfiguration);
var targetClassOverrides = targetClassDefiniton.GetAllMembers().Single(mdb => mdb.Name == "WriteType").Overrides;
var mixinOverrides = targetClassDefiniton.Mixins[0].GetAllMembers().Single(mdb => mdb.Name == "WriteType").Overrides;
Assert.That(targetClassOverrides.Count, Is.EqualTo(0));
Assert.That(mixinOverrides.Count, Is.EqualTo(1));
Assert.That(mixinOverrides[0].DeclaringClass.Type, Is.EqualTo(typeof(TargetOverrideMixin)));
}
public void GetTargetClassDefinition()
{
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass <TargetClass1> ()
.AddMixin <Mixin1> ()
.BuildConfiguration();
var reflectedOutput = _remotionReflector.GetTargetClassDefinition(typeof(TargetClass1), new ReflectedObject(mixinConfiguration), new ReflectedObject(mixinConfiguration.ClassContexts.GetWithInheritance(typeof(TargetClass1))));
var expectedOutput = TargetClassDefinitionUtility.GetConfiguration(typeof(TargetClass1), mixinConfiguration);
Assert.That(reflectedOutput.To <TargetClassDefinition> (), Is.InstanceOf(typeof(TargetClassDefinition)));
Assert.That(reflectedOutput.To <TargetClassDefinition> ().FullName, Is.EqualTo(expectedOutput.FullName));
}
public void GenerateXml()
{
var type = typeof(MemberOverrideTestClass.Target);
var mixinConfiguration =
MixinConfiguration.BuildNew().ForClass <MemberOverrideTestClass.Target> ().AddMixin <MemberOverrideTestClass.Mixin1> ().BuildConfiguration();
var targetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(type, mixinConfiguration));
var involvedType = new InvolvedType(type);
involvedType.TargetClassDefinition = targetClassDefinition;
var memberIdentifierGenerator = new IdentifierGenerator <MemberInfo> ();
var reportGenerator = new MemberReportGenerator(type, involvedType, new IdentifierGenerator <Type> (), memberIdentifierGenerator, _outputFormatter);
var output = reportGenerator.GenerateXml();
var expectedOutput = new XElement(
"Members",
new XElement(
"Member",
new XAttribute("id", "0"),
new XAttribute("type", MemberTypes.Constructor),
new XAttribute("name", ".ctor"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("", "public"),
_outputFormatter.CreateConstructorMarkup("Target", new ParameterInfo[0])
),
new XElement(
"Member",
new XAttribute("id", "1"),
new XAttribute("type", MemberTypes.Method),
new XAttribute("name", "OverriddenMethod"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("", "public virtual"),
_outputFormatter.CreateMethodMarkup("OverriddenMethod", typeof(void), new ParameterInfo[0]),
GenerateOverrides("Mixin-Reference", "0", "MemberOverrideTestClass+Mixin1")
),
new XElement(
"Member",
new XAttribute("id", "3"),
new XAttribute("type", MemberTypes.Method),
new XAttribute("name", "TemplateMethod"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("OverrideMixin ", "public"),
_outputFormatter.CreateMethodMarkup("TemplateMethod", typeof(void), new ParameterInfo[0]),
GenerateOverriddenMember("2", "TemplateMethod", "Void TemplateMethod()")
)
);
XElementComparisonHelper.Compare(output, expectedOutput);
}
public void GetTargetClassDefinition()
{
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass <TargetClass1>().AddMixin <Mixin1>()
.BuildConfiguration();
var involvedTypeFinder = CreateInvolvedTypeFinder(mixinConfiguration, typeof(UselessObject).Assembly);
var targetType = typeof(TargetClass1);
var classContextForTargetType = new ReflectedObject(mixinConfiguration.ClassContexts.GetWithInheritance(targetType));
var output = involvedTypeFinder.GetTargetClassDefinition(targetType, classContextForTargetType).To <TargetClassDefinition>();
var expectedOutput = TargetClassDefinitionUtility.GetConfiguration(targetType, mixinConfiguration);
Assert.That(output, Is.EqualTo(expectedOutput));
}
public void GenerateXml_WithMixins()
{
var targetType = new InvolvedType(typeof(TargetClass1));
var mixinConfiguration = MixinConfiguration.BuildNew().ForClass <TargetClass1> ().AddMixin <Mixin1> ().BuildConfiguration();
targetType.ClassContext = new ReflectedObject(mixinConfiguration.ClassContexts.First());
targetType.TargetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(targetType.Type, mixinConfiguration));
var interfaceIdentifierGenerator = new IdentifierGenerator <Type> ();
var attributeIdentifierGenerator = new IdentifierGenerator <Type> ();
var assemblyIdentifierGenerator = new IdentifierGenerator <Assembly> ();
var reportGenerator = new MixinReferenceReportGenerator(
targetType, assemblyIdentifierGenerator,
new IdentifierGenerator <Type> (),
interfaceIdentifierGenerator,
attributeIdentifierGenerator,
_remotionReflector,
_outputFormatter
);
var output = reportGenerator.GenerateXml();
var targetClassDefinition = TargetClassDefinitionUtility.GetConfiguration(targetType.Type, mixinConfiguration);
var mixinDefinition = targetClassDefinition.GetMixinByConfiguredType(typeof(Mixin1));
var expectedOutput = new XElement(
"Mixins",
new XElement(
"Mixin",
new XAttribute("ref", "0"),
new XAttribute("index", "0"),
new XAttribute("relation", "Extends"),
new XAttribute("instance-name", "Mixin1"),
new XAttribute("introduced-member-visibility", "private"),
// has no dependencies
new XElement("AdditionalDependencies"),
new InterfaceIntroductionReportGenerator(new ReflectedObject(mixinDefinition.InterfaceIntroductions), interfaceIdentifierGenerator).
GenerateXml(),
new AttributeIntroductionReportGenerator(
new ReflectedObject(mixinDefinition.AttributeIntroductions), attributeIdentifierGenerator, Helpers.RemotionReflectorFactory.GetRemotionReflection()).
GenerateXml(),
new MemberOverrideReportGenerator(new ReflectedObject(mixinDefinition.GetAllOverrides())).GenerateXml(),
new TargetCallDependenciesReportGenerator(new ReflectedObject(mixinDefinition), assemblyIdentifierGenerator, _remotionReflector, _outputFormatter).GenerateXml()
));
Assert.That(output.ToString(), Is.EqualTo(expectedOutput.ToString()));
}
public void Equals_False_TargetClassDefintionDoesntMatch()
{
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass <TargetClass1>().AddMixin <Mixin1>()
.ForClass <TargetClass2>().AddMixin <Mixin2>()
.BuildConfiguration();
var type1 = new InvolvedType(typeof(TargetClass1));
var type2 = new InvolvedType(typeof(TargetClass1));
type1.TargetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(typeof(TargetClass1), mixinConfiguration));
type2.TargetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(typeof(TargetClass2), mixinConfiguration));
Assert.That(type1, Is.Not.EqualTo(type2));
}
public void TargetClassDefinitionProperty_ForNonGenericTargetClass()
{
var type = typeof(TargetClass1);
var mixinConfiguration = MixinConfiguration.BuildNew()
.ForClass(type).AddMixin <Mixin1>()
.BuildConfiguration();
var type1 = new InvolvedType(type);
type1.ClassContext = new ReflectedObject(mixinConfiguration.ClassContexts.First());
type1.TargetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(type, mixinConfiguration));
Assert.That(type1.IsTarget, Is.True);
Assert.That(type1.ClassContext, Is.Not.Null);
}
public void HasAlphabeticOrderingAttribute_True()
{
var mixinConfiguration =
MixinConfiguration.BuildNew().ForClass <UselessObject> ().AddMixin <ClassWithAlphabeticOrderingAttribute> ().BuildConfiguration();
var involvedType = new InvolvedType(typeof(ClassWithAlphabeticOrderingAttribute));
involvedType.TargetTypes.Add(
new InvolvedType(typeof(UselessObject)),
new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(typeof(UselessObject), mixinConfiguration).Mixins[0]));
var reportGenerator = ReportBuilder.CreateInvolvedTypeReportGenerator(_remotionReflector, _outputFormatter);
var output = reportGenerator.GetAlphabeticOrderingAttribute(involvedType);
Assert.That(output, Is.EqualTo("AcceptsAlphabeticOrdering "));
}
public void HasOverrideMixinAttribute_True()
{
var type = typeof(MemberOverrideTestClass.Target);
var mixinConfiguration =
MixinConfiguration.BuildNew().ForClass <MemberOverrideTestClass.Target> ().AddMixin <MemberOverrideTestClass.Mixin1> ().BuildConfiguration();
var targetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(type, mixinConfiguration));
var involvedType = new InvolvedType(type)
{
TargetClassDefinition = targetClassDefinition
};
var reportGenerator = CreateMemberReportGenerator(type, involvedType);
var output = reportGenerator.GenerateXml().XPathSelectElement("Member[@name='TemplateMethod']").Element("Modifiers").Element("Type");
Assert.That(output.Value, Is.EqualTo("OverrideMixin"));
}
public void GetOverrides_WithoutOverrides_ForMemberHiddenByDerivedClass()
{
var targetType = typeof(HiddenMemberTestClass.Target);
var mixinConfiguration =
MixinConfiguration.BuildNew()
.ForClass <HiddenMemberTestClass.Target> ().AddMixin <HiddenMemberTestClass.Mixin1> ()
.BuildConfiguration();
var targetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(targetType, mixinConfiguration));
var involvedType = new InvolvedType(targetType)
{
TargetClassDefinition = targetClassDefinition,
ClassContext = new ReflectedObject(mixinConfiguration.ClassContexts.First())
};
var reportGenerator = CreateMemberReportGenerator(targetType, involvedType);
var output = reportGenerator.GenerateXml();
Assert.That(output.XPathSelectElements("Member[@name='HiddenMethod']/Overrides").Any(), Is.False);
}
public void GenerateXml_MixinWithOverriddenClassMember()
{
var mixinType = typeof(MixinWithInheritedMethod);
var targetType = typeof(ClassOverridingInheritedMixinMethod);
var mixin = new InvolvedType(mixinType);
var target = new InvolvedType(targetType);
var mixinConfiguration =
MixinConfiguration.BuildNew().ForClass <ClassOverridingInheritedMixinMethod> ().AddMixin <MixinWithInheritedMethod> ().BuildConfiguration();
var targetClassDefinition = TargetClassDefinitionUtility.GetConfiguration(targetType, mixinConfiguration);
mixin.TargetTypes.Add(target, new ReflectedObject(targetClassDefinition.GetMixinByConfiguredType(mixinType)));
var reportGenerator = CreateMemberReportGenerator(mixinType, mixin);
var output = reportGenerator.GenerateXml();
var expectedOutput = new XElement(
"Members",
new XElement(
"Member",
new XAttribute("id", "0"),
new XAttribute("type", MemberTypes.Constructor),
new XAttribute("name", ".ctor"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("", "public"),
_outputFormatter.CreateConstructorMarkup("MixinWithInheritedMethod", new ParameterInfo[0])
),
new XElement(
"Member",
new XAttribute("id", "1"),
new XAttribute("type", MemberTypes.Method),
new XAttribute("name", "ProtectedInheritedMethod"),
new XAttribute("is-declared-by-this-class", false),
_outputFormatter.CreateModifierMarkup("", "protected virtual"),
_outputFormatter.CreateMethodMarkup("ProtectedInheritedMethod", typeof(string), new ParameterInfo[0]),
GenerateOverrides("Target-Reference", "0", "ClassOverridingInheritedMixinMethod")
)
);
XElementComparisonHelper.Compare(output, expectedOutput);
}
public void GetOverrides_NoOverrides()
{
var targetType = typeof(TargetClass1);
var mixinConfiguration =
MixinConfiguration.BuildNew()
.ForClass <TargetClass1> ().AddMixin <Mixin1> ()
.BuildConfiguration();
var targetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(targetType, mixinConfiguration));
var involvedType = new InvolvedType(targetType)
{
TargetClassDefinition = targetClassDefinition,
ClassContext = new ReflectedObject(mixinConfiguration.ClassContexts.First())
};
var reportGenerator = CreateMemberReportGenerator(targetType, involvedType);
//var memberInfo = targetType.GetMember ("Dispose")[0];
var output = reportGenerator.GenerateXml();
Assert.That(output.XPathSelectElements("Member[@name='Dispose']/Overrides").Any(), Is.False);
}
public void MemberEquals_False()
{
var targetType = typeof(BaseMemberOverrideTestClass.Target);
var mixinConfiguration =
MixinConfiguration.BuildNew()
.ForClass <BaseMemberOverrideTestClass.Target> ().AddMixin <BaseMemberOverrideTestClass.Mixin1> ()
.BuildConfiguration();
var targetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(targetType, mixinConfiguration));
var involvedType = new InvolvedType(targetType)
{
TargetClassDefinition = targetClassDefinition,
ClassContext = new ReflectedObject(mixinConfiguration.ClassContexts.First())
};
var memberInfo1 = typeof(HiddenMemberTestClass.Target).GetMember("HiddenMethod")[0];
var output =
involvedType.TargetClassDefinition.CallMethod("GetAllMembers").SingleOrDefault(
mdb => MemberInfoEqualityUtility.MemberEquals(mdb.GetProperty("MemberInfo").To <MemberInfo> (), memberInfo1));
Assert.That(output, Is.Null);
}
private void SetTargetClassDefinition(InvolvedType involvedType, MixinConfiguration mixinConfiguration)
{
involvedType.TargetClassDefinition = new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(involvedType.Type, mixinConfiguration));
}
private ReflectedObject GetMemberOverrides(InvolvedType targetType, Type mixinType, MixinConfiguration mixinConfiguration)
{
var targetClassDefinition = TargetClassDefinitionUtility.GetConfiguration(targetType.Type, mixinConfiguration);
return(new ReflectedObject(targetClassDefinition.GetMixinByConfiguredType(mixinType).GetAllOverrides()));
}
private ReflectedObject CreateTargetClassDefintion <ForType> (MixinConfiguration mixinConfiguration)
{
return(new ReflectedObject(TargetClassDefinitionUtility.GetConfiguration(typeof(ForType), mixinConfiguration)));
}
