public TargetCallDependenciesReportGenerator(ReflectedObject mixinDefinition, IIdentifierGenerator <Assembly> assemblyIdentifierGenerator, IRemotionReflector remotionReflector, IOutputFormatter outputFormatter)
{
_mixinDefinition = mixinDefinition;
_assemblyIdentifierGenerator = assemblyIdentifierGenerator;
_remotionReflector = remotionReflector;
_outputFormatter = outputFormatter;
}
public void CallMethod_ExistingMethod()
{
var reflectedObject = new ReflectedObject ("stringContent");
var output = reflectedObject.CallMethod ("IndexOf", 't');
Assert.That (output.To<int>(), Is.EqualTo (1));
}
public ReflectedObject GetTargetClassDefinition(Type type, ReflectedObject classContext)
{
if (type.IsGenericTypeDefinition || type.IsInterface)
{
return(null);
}
try
{
// may throw ConfigurationException or ValidationException
return(_remotionReflector.GetTargetClassDefinition(type, _mixinConfiguration, classContext));
}
catch (Exception configurationOrValidationException)
{
if (_remotionReflector.IsConfigurationException(configurationOrValidationException))
{
_configurationErrors.AddException(configurationOrValidationException);
}
else if (_remotionReflector.IsValidationException(configurationOrValidationException))
{
_validationErrors.AddException(configurationOrValidationException);
}
else
{
throw;
}
}
// MixinConfiguration is not valid
return(null);
}
private XElement CreateDependencyElement(ReflectedObject targetCallDependencyDefinition)
{
var targetClassDefinition = _mixinDefinition.GetProperty("TargetClass");
var requiredType = targetCallDependencyDefinition.GetProperty("RequiredType").GetProperty("Type").To <Type> ();
var element = new XElement("Dependency",
new XAttribute("assembly-ref",
_assemblyIdentifierGenerator.GetIdentifier(requiredType.Assembly)),
new XAttribute("metadataToken", requiredType.MetadataToken),
new XAttribute("namespace", requiredType.Namespace),
new XAttribute("name", _outputFormatter.GetShortFormattedTypeName(requiredType)),
new XAttribute("is-interface", requiredType.IsInterface));
if (requiredType.IsInterface)
{
var implementedByTarget = targetClassDefinition.GetProperty("ImplementedInterfaces").Any(i => i.To <Type> () == requiredType);
var addedByMixin = targetClassDefinition.GetProperty("ReceivedInterfaces").Any(i => i.GetProperty("InterfaceType").To <Type> () == requiredType);
var implementedDynamically = !implementedByTarget && !addedByMixin;
element.Add(new XAttribute("is-implemented-by-target", implementedByTarget));
element.Add(new XAttribute("is-added-by-mixin", addedByMixin));
element.Add(new XAttribute("is-implemented-dynamically", implementedDynamically));
}
return(element);
}
public virtual void Intercept(IInvocation invocation)
{
Method method = new Method(invocation.Method);
bool snapShotEnabled = method.HasAttribute(typeof(WorkSnapshotAttribute));
LastServiceCallStatus lastServiceCallStatus = serviceExecution.Invoking(service, invocation.Method);
if (lastServiceCallStatus.WasExecuted)
{
invocation.ReturnValue = lastServiceCallStatus.ReturnValue;
}
else
{
if (snapShotEnabled)
{
serviceExecution.TakeSnapshot();
}
ReflectedObject reflectedServiceObject = new ReflectedObject(service);
sessionReport.Begin(invocation.Method.Name);
try
{
invocation.ReturnValue = reflectedServiceObject.Invoke(invocation.Method, invocation.Arguments);
serviceExecution.Invoked(invocation.ReturnValue);
}
catch (Exception e)
{
sessionReport.Act();
serviceExecution.Error();
throw new WhiteException(string.Format("Error Invoking {0}.{1}", reflectedServiceObject.Class.Name, invocation.Method.Name), e.InnerException);
}
}
}
public TargetCallDependenciesReportGenerator(ReflectedObject mixinDefinition, IIdentifierGenerator<Assembly> assemblyIdentifierGenerator, IRemotionReflector remotionReflector, IOutputFormatter outputFormatter)
{
_mixinDefinition = mixinDefinition;
_assemblyIdentifierGenerator = assemblyIdentifierGenerator;
_remotionReflector = remotionReflector;
_outputFormatter = outputFormatter;
}
bool CheckHover(ReflectedObject reflected)
{
if (!ImGui.IsItemHovered())
{
return(false);
}
if (_lastHoveredItem != reflected)
{
if (_lastHoveredItem?.Target != null &&
_behaviours.TryGetValue(_lastHoveredItem.Target.GetType(), out var blurredCallback))
{
blurredCallback(DebugInspectorAction.Blur, _lastHoveredItem);
}
if (reflected.Target != null &&
_behaviours.TryGetValue(reflected.Target.GetType(), out var hoverCallback))
{
hoverCallback(DebugInspectorAction.Hover, reflected);
}
_lastHoveredItem = reflected;
}
return(true);
}
public static void PropertyField(ReflectedObject obj)
{
obj.Root.Drawer.Initialize();
Rect rect = EditorGUILayout.GetControlRect(true, obj.Root.Drawer.GetPropertyHeight(obj.Root), (GUILayoutOption[])null);
EditorGUIX.PropertyField(rect, obj.Root);
}
public void CallMethod_ExistingMethod_WithReflectedObject()
{
var reflectedObject = new ReflectedObject("stringContent");
var output = reflectedObject.CallMethod("IndexOf", new ReflectedObject('t'));
Assert.That(output.To <int>(), Is.EqualTo(1));
}
public void GetHashCode_Same()
{
var reflectedObject1 = new ReflectedObject("string");
var reflectedObject2 = new ReflectedObject("string");
Assert.That(reflectedObject1.GetHashCode(), Is.EqualTo(reflectedObject2.GetHashCode()));
}
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 Equals_True_Unwrap()
{
var reflectedObject1 = new ReflectedObject("string");
var reflectedObject2 = new ReflectedObject("string");
Assert.True(reflectedObject1.Equals(reflectedObject2));
}
public void Equals_False()
{
var reflectedObject1 = new ReflectedObject("string");
var reflectedObject2 = new ReflectedObject("anotherString");
Assert.False(reflectedObject1.Equals(reflectedObject2));
}
public void ToString_Test()
{
const string content = "toString() for string";
var reflectedObject = new ReflectedObject(content);
Assert.That(reflectedObject.ToString(), Is.EqualTo(content));
}
public void Create_ConstructorWithWrappedArguments()
{
var reflectedObject = ReflectedObject.Create(typeof(string).Assembly, "System.String", 'x', new ReflectedObject(5));
var expectedOutput = new String('x', 5);
Assert.That(reflectedObject.To <string>(), Is.EqualTo(expectedOutput));
}
public void CallMethod_Static()
{
// public static bool string.IsNullOrEmpty (string aString);
var output = ReflectedObject.CallMethod(typeof(string), "IsNullOrEmpty", "notEmpty");
Assert.That(output.To <bool>(), Is.False);
}
public void GetProperty_ExistingProperty()
{
var reflectedObject = new ReflectedObject("string");
var output = reflectedObject.GetProperty("Length");
Assert.That(output.To <int>(), Is.EqualTo(6));
}
public void To_CorrespondingType()
{
var reflectedObject = new ReflectedObject("string");
String output = reflectedObject.To <String>();
Assert.That(output, Is.EqualTo("string"));
}
public void GetHashCode_Different()
{
var reflectedObject1 = new ReflectedObject("string");
var reflectedObject2 = new ReflectedObject("anotherString");
Assert.That(reflectedObject1.GetHashCode(), Is.Not.EqualTo(reflectedObject2.GetHashCode()));
}
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 Equals_False_Unsymetric()
{
var reflectedObject1 = new ReflectedObject("string");
// would be nice but does not follow the equals contract (symmetric)
// Assert.That (reflectedObject1, Is.EqualTo ("string"));
Assert.That(reflectedObject1, Is.Not.EqualTo("string"));
}
private XElement GenerateOverriddenMemberElement(ReflectedObject overriddenMember)
{
return(new XElement(
"OverriddenMember",
new XAttribute("type", overriddenMember.GetProperty("MemberType")),
new XAttribute("name", overriddenMember.GetProperty("Name"))
));
}
public void GetComposedInterfaces()
{
var classContext = new ReflectedObject (new ClassContext (typeof (object), new MixinContext[0], new[] { typeof (int), typeof (double) }));
var result = _remotionReflector.GetComposedInterfaces (classContext);
Assert.That (result, Is.EqualTo (new[] { typeof (int), typeof (double) }));
}
public void ReflectedTypeCreation_SimpleObjectWithTwoMembers_CorrectReflectedType()
{
var o = new TestObjectWith2AttributedInners(new InnerObject1(), new InnerObject2());
var reflectedObject = new ReflectedObject(o);
Assert.IsNotNull(reflectedObject);
Assert.AreEqual(new[] { new ReflectedObject(o.InnerObject1), new ReflectedObject(o.InnerObject2) }, reflectedObject.InnerObjectsDescriptors.ToArray());
}
public void CallMethod_ExistingMethod_Void()
{
// TargetDoSomething has method: public void DoSomething()
var reflectedObject = new ReflectedObject(new TargetDoSomething());
var output = reflectedObject.CallMethod("DoSomething");
Assert.That(output, Is.Null);
}
public virtual ReflectedObject GetTargetClassDefinition(Type targetType, ReflectedObject mixinConfiguration, ReflectedObject classContext)
{
ArgumentUtility.CheckNotNull ("targetType", targetType);
ArgumentUtility.CheckNotNull ("mixinConfiguration", mixinConfiguration);
var targetClassDefinitionUtilityType = _remotionAssembly.GetType ("Remotion.Mixins.TargetClassDefinitionUtility", true);
return ReflectedObject.CallMethod (targetClassDefinitionUtilityType, "GetConfiguration", targetType, mixinConfiguration);
}
public override ReflectedObject GetTargetClassDefinition(Type targetType, ReflectedObject mixinConfiguration, ReflectedObject classContext)
{
ArgumentUtility.CheckNotNull ("targetType", targetType);
ArgumentUtility.CheckNotNull ("mixinConfiguration", mixinConfiguration);
var targetClassDefinitionFactoryType = RemotionAssembly.GetType ("Remotion.Mixins.Definitions.TargetClassDefinitionFactory", true);
return ReflectedObject.CallMethod (targetClassDefinitionFactoryType, "CreateTargetClassDefinition", classContext);
}
public void ReadStruct()
{
ReflectedObject root = new ReflectedObject(new TestVector());
Assert.AreEqual(root["vec"]["x"].Value, 1f);
Assert.AreEqual(root["vec"]["y"].Value, 2f);
Assert.AreEqual(root["vec"]["z"].Value, 3f);
}
public void ReflectedTypeCreation_NonAttributedObject_DontThrowsException(Type t)
{
Object o = Activator.CreateInstance(t);
ReflectedObject reflectedObject = null;
Assert.DoesNotThrow(() => reflectedObject = new ReflectedObject(o));
Assert.That(reflectedObject, Is.Not.Null);
Assert.That(reflectedObject.InnerObjectsDescriptors.Count(), Is.EqualTo(0));
}
private string GetRelationName(ReflectedObject mixinContext)
{
if (mixinContext.GetProperty("MixinKind").ToString().Equals("Extending"))
{
return("Extends");
}
return("Used by");
}
public override ReflectedObject BuildConfigurationFromAssemblies(Assembly[] assemblies)
{
ArgumentUtility.CheckNotNull("assemblies", assemblies);
var declarativeConfigurationBuilderType = RemotionAssembly.GetType("Remotion.Mixins.Context.DeclarativeConfigurationBuilder", true);
return(ReflectedObject.CallMethod(declarativeConfigurationBuilderType, "BuildConfigurationFromAssemblies", new object[] { assemblies }));
}
public void GetComposedInterfaces()
{
var classContext = new ReflectedObject(new ClassContext(typeof(object), new MixinContext[0], new[] { typeof(int), typeof(double) }));
var result = _remotionReflector.GetComposedInterfaces(classContext);
Assert.That(result, Is.EqualTo(new[] { typeof(int), typeof(double) }));
}
public void SetsChangedProperty()
{
ReflectedObject obj = new ReflectedObject(new Thing());
Assert.IsFalse(obj.HasModifiedProperties);
obj["x"].Value = 2f;
Assert.IsTrue(obj.HasModifiedProperties);
}
public virtual ReflectedObject GetTargetClassDefinition(Type targetType, ReflectedObject mixinConfiguration, ReflectedObject classContext)
{
ArgumentUtility.CheckNotNull("targetType", targetType);
ArgumentUtility.CheckNotNull("mixinConfiguration", mixinConfiguration);
var targetClassDefinitionUtilityType = _remotionAssembly.GetType("Remotion.Mixins.TargetClassDefinitionUtility", true);
return(ReflectedObject.CallMethod(targetClassDefinitionUtilityType, "GetConfiguration", targetType, mixinConfiguration));
}
public override ReflectedObject GetTargetClassDefinition(Type targetType, ReflectedObject mixinConfiguration, ReflectedObject classContext)
{
ArgumentUtility.CheckNotNull("targetType", targetType);
ArgumentUtility.CheckNotNull("mixinConfiguration", mixinConfiguration);
var targetClassDefinitionFactoryType = RemotionAssembly.GetType("Remotion.Mixins.Definitions.TargetClassDefinitionFactory", true);
return(ReflectedObject.CallMethod(targetClassDefinitionFactoryType, "CreateTargetClassDefinition", classContext));
}
public void ReflectedTypeCreation_NonAttributedObject_DontThrowsException(Type t)
{
Object o = Activator.CreateInstance(t);
ReflectedObject reflectedObject = null;
Assert.DoesNotThrow(() => reflectedObject = new ReflectedObject(o));
Assert.That(reflectedObject, Is.Not.Null);
Assert.That(reflectedObject.InnerObjectsDescriptors.Count(), Is.EqualTo(0));
}
public void ReflectedTypeCreation_SimpleObjectWithTwoMembersOneNull_CorrectReflectedType()
{
var o = new TestObjectWith2AttributedInners(new InnerObject1(), null);
var reflectedObject = new ReflectedObject(o);
Assert.IsNotNull(reflectedObject);
Assert.AreEqual(new IObjectDescriptor[] { new ReflectedObject(o.InnerObject1), new NullReflectedObject() }, reflectedObject.InnerObjectsDescriptors.ToArray());
}
public void AsEnumerable()
{
var reflectedObject = new ReflectedObject ("string");
var output = new StringBuilder (6);
foreach (var character in reflectedObject.AsEnumerable<char>())
output.Append (character);
Assert.That (output.ToString(), Is.EqualTo ("string"));
}
public InterfaceIntroductionReportGenerator(
ReflectedObject interfaceIntroductionDefinitions,
IIdentifierGenerator<Type> interfaceIdentifierGenerator)
{
ArgumentUtility.CheckNotNull ("interfaceIntroductionDefinitions", interfaceIntroductionDefinitions);
ArgumentUtility.CheckNotNull ("interfaceIdentifierGenerator", interfaceIdentifierGenerator);
_interfaceIntroductionDefinitions = interfaceIntroductionDefinitions;
_interfaceIdentifierGenerator = interfaceIdentifierGenerator;
}
public void GenerateXml_NoDependencies()
{
// Mixin1 has no depencies
var explicitDependencies = _mixinConfiguration.ClassContexts.Single().Mixins.First().ExplicitDependencies;
var dependencies = new ReflectedObject (explicitDependencies);
var output = new AdditionalDependencyReportGenerator (dependencies, _identifierGenerator, _outputFormatter).GenerateXml();
var expectedOutput = new XElement ("AdditionalDependencies");
Assert.That (output.ToString(), Is.EqualTo (expectedOutput.ToString()));
}
public AttributeIntroductionReportGenerator(
ReflectedObject attributeIntroductionDefinitions,
IIdentifierGenerator<Type> attributeIdentifierGenerator,
IRemotionReflector remotionReflector)
{
ArgumentUtility.CheckNotNull ("attributeIntroductionDefinitions", attributeIntroductionDefinitions);
ArgumentUtility.CheckNotNull ("attributeIdentifierGenerator", attributeIdentifierGenerator);
ArgumentUtility.CheckNotNull ("remotionReflector", remotionReflector);
_attributeIntroductionDefinitions = attributeIntroductionDefinitions;
_attributeIdentifierGenerator = attributeIdentifierGenerator;
_remotionReflector = remotionReflector;
}
public AdditionalDependencyReportGenerator(
ReflectedObject explicitDependencies,
IIdentifierGenerator<Type> involvedTypeIdentifierGenerator,
IOutputFormatter outputFormatter)
{
ArgumentUtility.CheckNotNull ("explicitDependencies", explicitDependencies);
ArgumentUtility.CheckNotNull ("involvedTypeIdentifierGenerator", involvedTypeIdentifierGenerator);
ArgumentUtility.CheckNotNull ("outputFormatter", outputFormatter);
_explicitDependencies = explicitDependencies;
_involvedTypeIdentifierGenerator = involvedTypeIdentifierGenerator;
_outputFormatter = outputFormatter;
}
public virtual bool Compare(object original, object changed, LeafRegistry registry)
{
var reflectedChanged = new ReflectedObject(changed, registry);
var reflectedOriginal = new ReflectedObject(original, registry);
if (ReferenceEquals(original, changed))
{
return false;
}
else
{
reflectedOriginal.AreIdentical(reflectedChanged);
return true;
}
}
public void AsEnumerable_NonEnumerable()
{
var reflectedObject = new ReflectedObject (42);
try
{
reflectedObject.AsEnumerable<object>().GetEnumerator().MoveNext();
Assert.Fail ("expected exception not thrown");
}
catch (NotSupportedException notSupportedException)
{
Assert.That (notSupportedException.Message, Is.EqualTo ("The reflected object 'System.Int32' is not enumerable."));
}
}
public void AsEnumerable_EnumerableButWrongType()
{
var reflectedObject = new ReflectedObject ("string");
try
{
// 'char' is convertible to 'int'!
reflectedObject.AsEnumerable<float>().GetEnumerator().MoveNext();
Assert.Fail ("expected exception not thrown");
}
catch (InvalidCastException notSupportedException)
{
Assert.That (notSupportedException.Message, Is.EqualTo ("Specified cast is not valid."));
}
}
public InvolvedTypeMember(MemberInfo memberInfo, ReflectedObject targetMemberDefinition,
IEnumerable<ReflectedObject> mixinMemberDefinitions)
{
ArgumentUtility.CheckNotNull("memberInfo", memberInfo);
MemberInfo = new OverridingMemberInfo(memberInfo);
AddSubMemberInfos(memberInfo);
SetMixinOverride(targetMemberDefinition);
AddTargetOverrides(mixinMemberDefinitions);
MixinMemberDefinitions = mixinMemberDefinitions ?? Enumerable.Empty<ReflectedObject>();
TargetMemberDefinition = targetMemberDefinition;
OverridingMixinTypes = GetOverridingMixinTypes();
OverridingTargetTypes = GetOverridingTargetTypes();
}
public void GenerateXml_WithDependencies()
{
var explicitDependencies = _mixinConfiguration.ClassContexts.Single().Mixins.Last().ExplicitDependencies;
var dependencies = new ReflectedObject (explicitDependencies);
var output = new AdditionalDependencyReportGenerator (dependencies, _identifierGenerator, _outputFormatter).GenerateXml ();
var expectedOutput = new XElement (
"AdditionalDependencies",
new XElement (
"AdditionalDependency",
new XAttribute ("ref", "0"),
new XAttribute ("instance-name", "AdditionalDependenciesTest+Mixin1")),
new XElement (
"AdditionalDependency",
new XAttribute ("ref", "1"),
new XAttribute ("instance-name", "AdditionalDependenciesTest+Mixin2"))
);
Assert.That (output.ToString(), Is.EqualTo (expectedOutput.ToString()));
}
public InvolvedTypeFinder(
ReflectedObject mixinConfiguration,
Assembly[] assemblies,
ErrorAggregator<Exception> configurationErrors,
ErrorAggregator<Exception> validationErrors,
IRemotionReflector remotionReflector
)
{
ArgumentUtility.CheckNotNull ("mixinConfiguration", mixinConfiguration);
ArgumentUtility.CheckNotNull ("assemblies", assemblies);
ArgumentUtility.CheckNotNull ("configurationErrors", configurationErrors);
ArgumentUtility.CheckNotNull ("validationErrors", validationErrors);
ArgumentUtility.CheckNotNull ("remotionReflector", remotionReflector);
_mixinConfiguration = mixinConfiguration;
_assemblies = assemblies;
_configurationErrors = configurationErrors;
_validationErrors = validationErrors;
_remotionReflector = remotionReflector;
}
public void MemberEquals_True()
{
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 = targetType.GetMember ("OverriddenMethod")[0];
var output =
involvedType.TargetClassDefinition.CallMethod ("GetAllMembers").SingleOrDefault (
mdb => MemberInfoEqualityUtility.MemberEquals (mdb.GetProperty ("MemberInfo").To<MemberInfo> (), memberInfo1));
Assert.That (output.To<object> (), Is.Not.Null);
}
private XElement CreateDependencyElement(ReflectedObject targetCallDependencyDefinition)
{
var targetClassDefinition = _mixinDefinition.GetProperty ("TargetClass");
var requiredType = targetCallDependencyDefinition.GetProperty ("RequiredType").GetProperty ("Type").To<Type> ();
var element = new XElement("Dependency",
new XAttribute("assembly-ref",
_assemblyIdentifierGenerator.GetIdentifier(requiredType.Assembly)),
new XAttribute("metadataToken", requiredType.MetadataToken),
new XAttribute("namespace", requiredType.Namespace),
new XAttribute("name", _outputFormatter.GetShortFormattedTypeName(requiredType)),
new XAttribute("is-interface", requiredType.IsInterface));
if (requiredType.IsInterface)
{
var implementedByTarget = targetClassDefinition.GetProperty ("ImplementedInterfaces").Any (i => i.To<Type> () == requiredType);
var addedByMixin = targetClassDefinition.GetProperty ("ReceivedInterfaces").Any (i => i.GetProperty ("InterfaceType").To<Type> () == requiredType);
var implementedDynamically = !implementedByTarget && !addedByMixin;
element.Add (new XAttribute ("is-implemented-by-target", implementedByTarget));
element.Add (new XAttribute ("is-added-by-mixin", addedByMixin));
element.Add (new XAttribute ("is-implemented-dynamically", implementedDynamically));
}
return element;
}
public ReflectedObject GetTargetClassDefinition(Type type, ReflectedObject classContext)
{
if (type.IsGenericTypeDefinition || type.IsInterface)
return null;
try
{
// may throw ConfigurationException or ValidationException
return _remotionReflector.GetTargetClassDefinition (type, _mixinConfiguration, classContext);
}
catch (Exception configurationOrValidationException)
{
if (_remotionReflector.IsConfigurationException (configurationOrValidationException))
_configurationErrors.AddException (configurationOrValidationException);
else if (_remotionReflector.IsValidationException (configurationOrValidationException))
_validationErrors.AddException (configurationOrValidationException);
else
throw;
}
// MixinConfiguration is not valid
return null;
}
private ReflectedObject GetMixinDefiniton(Type mixinType, ReflectedObject targetClassDefinition)
{
return targetClassDefinition == null ? null : targetClassDefinition.CallMethod ("GetMixinByConfiguredType", mixinType);
}
private string GetRelationName(ReflectedObject mixinContext)
{
if (mixinContext.GetProperty ("MixinKind").ToString ().Equals ("Extending"))
return "Extends";
return "Used by";
}
public override ReflectedObject GetTargetCallDependencies(ReflectedObject mixinDefinition)
{
throw CreateException();
}
public ReflectedObject GetTargetCallDependencies(ReflectedObject mixinDefinition)
{
return mixinDefinition;
}
public ICollection<Type> GetComposedInterfaces(ReflectedObject classContext)
{
return new Type[0];
}
private void SetMixinOverride(ReflectedObject targetMemberDefinition)
{
if (targetMemberDefinition == null)
return;
var baseMember = targetMemberDefinition.GetProperty ("BaseAsMember");
if (baseMember == null)
return;
AddOverriddenMember(baseMember.GetProperty ("MemberInfo").To<MemberInfo> (), OverridingMemberInfo.OverrideType.Mixin);
}
private XElement GenerateMixinElement(ReflectedObject mixinContext)
{
var mixinType = mixinContext.GetProperty ("MixinType").To<Type>();
var mixinElement = new XElement (
"Mixin",
new XAttribute ("ref", _involvedTypeIdentifierGenerator.GetIdentifier (mixinType)),
new XAttribute ("index", "n/a"),
new XAttribute ("relation", GetRelationName(mixinContext)),
// property MixinType on mixinContext always return the generic type definition, not the type of the actual instance
new XAttribute ("instance-name", _outputFormatter.GetShortFormattedTypeName (mixinType)),
new XAttribute ("introduced-member-visibility", mixinContext.GetProperty ("IntroducedMemberVisibility").ToString().ToLower()),
new AdditionalDependencyReportGenerator (
mixinContext.GetProperty ("ExplicitDependencies"), _involvedTypeIdentifierGenerator, _outputFormatter).GenerateXml()
);
if (_involvedType.HasTargetClassDefintion)
{
var mixinDefinition = _involvedType.TargetClassDefinition.CallMethod (
"GetMixinByConfiguredType", mixinContext.GetProperty ("MixinType").To<Type>());
// set more specific name for mixin references
mixinElement.SetAttributeValue ("instance-name", _outputFormatter.GetShortFormattedTypeName (mixinDefinition.GetProperty ("Type").To<Type>()));
// set mixin index
mixinElement.SetAttributeValue ("index", mixinDefinition.GetProperty ("MixinIndex").To<int>());
mixinElement.Add (
new InterfaceIntroductionReportGenerator (mixinDefinition.GetProperty ("InterfaceIntroductions"), _interfaceIdentifierGenerator).
GenerateXml());
mixinElement.Add (
new AttributeIntroductionReportGenerator (
mixinDefinition.GetProperty ("AttributeIntroductions"), _attributeIdentifierGenerator, _remotionReflector).GenerateXml());
mixinElement.Add (
new MemberOverrideReportGenerator (mixinDefinition.CallMethod ("GetAllOverrides")).GenerateXml());
mixinElement.Add (new TargetCallDependenciesReportGenerator (mixinDefinition, _assemblyIdentifierGenerator, _remotionReflector, _outputFormatter).GenerateXml ());
}
return mixinElement;
}
public override ICollection<Type> GetComposedInterfaces(ReflectedObject classContext)
{
throw CreateException();
}
public override ReflectedObject GetTargetClassDefinition(Type targetType, ReflectedObject mixinConfiguration, ReflectedObject classContext)
{
throw CreateException();
}
