public void Merge_WhenClassesAreSpecified_PropertiesMergedCorrectly()
{
// arrange
var sourcePropertyIterator = new Mock<IInstanceMemberIterator<PropertyInfo, PropertySourceTest>>();
sourcePropertyIterator.Setup(p => p.GetEnumerator()).Returns(this.CreateSourceEnumerator);
var destinationPropertyIterator = new Mock<IInstanceMemberIterator<PropertyInfo, PropertyDestinationTest>>();
destinationPropertyIterator.Setup(p => p.GetEnumerator()).Returns(this.CreateDestinationEnumerator);
var iteratorFactory = new Mock<IIteratorFactory<PropertyInfo>>();
iteratorFactory.Setup(p => p.CreateSourceIterator<PropertySourceTest>()).Returns(sourcePropertyIterator.Object);
iteratorFactory.Setup(p => p.CreateDestinationIterator<PropertyDestinationTest>()).Returns(destinationPropertyIterator.Object);
// act
var mergeManager = new MemberMergeManager<PropertyInfo>(iteratorFactory.Object, _equalityComparerFactory);
var mergeResult = mergeManager.Merge<PropertySourceTest, PropertyDestinationTest>().Select(p => p.MemberInfo).ToList();
// assert
Type type = typeof(PropertyDestinationTest);
var expectedResult = new List<PropertyInfo>
{
type.GetProperty(Utils.GetPropertyName<PropertyDestinationTest, string>(p => p.PropString)),
type.GetProperty(Utils.GetPropertyName<PropertyDestinationTest, int>(p => p.PropInt1)),
type.GetProperty(Utils.GetPropertyName<PropertyDestinationTest, List<int>>(p => p.PropListInt))
};
Assert.Equal(expectedResult.OrderBy(p => p.Name), mergeResult.OrderBy(p => p.Name), _equalityComparerFactory.Create());
}
public void Merge_WhenClassesAreSpecified_FieldsMergedCorrectly()
{
// assign
var sourceFieldIterator = new Mock<IInstanceMemberIterator<FieldInfo, FieldSourceTest>>();
sourceFieldIterator.Setup(p => p.GetEnumerator()).Returns(this.CreateSourceEnumerator);
var destinationFieldIterator = new Mock<IInstanceMemberIterator<FieldInfo, FieldDestinationTest>>();
destinationFieldIterator.Setup(p => p.GetEnumerator()).Returns(this.CreateDestinationEnumerator);
var iteratorFactory = new Mock<IIteratorFactory<FieldInfo>>();
iteratorFactory.Setup(p => p.CreateSourceIterator<FieldSourceTest>()).Returns(sourceFieldIterator.Object);
iteratorFactory.Setup(p => p.CreateDestinationIterator<FieldDestinationTest>()).Returns(destinationFieldIterator.Object);
var mergeManager = new MemberMergeManager<FieldInfo>(iteratorFactory.Object, _equalityComparerFactory);
var mergeResult = mergeManager.Merge<FieldSourceTest, FieldDestinationTest>().Select(p => p.MemberInfo).ToList();
// assert
var type = typeof (FieldDestinationTest);
var expectedResult = new List<FieldInfo>
{
type.GetField(Utils.GetFieldName<FieldDestinationTest, string>(p => p.FieldString)),
type.GetField(Utils.GetFieldName<FieldDestinationTest, int>(p => p.FieldInt2)),
type.GetField(Utils.GetFieldName<FieldDestinationTest, List<string>>(p => p.FieldListString))
};
Assert.Equal(expectedResult.OrderBy(p => p.Name), mergeResult.OrderBy(p => p.Name), _equalityComparerFactory.Create());
}
public static TypeNode Create(NamespaceNode parent, IOldToNewTupleMap <TypeMetadata> map)
{
var oldTypeMetadata = map.OldType;
var newTypeMetadata = map.NewType;
IDecompilationResults oldResult = null;
IDecompilationResults newResult = null;
IDecompilationResults result;
if (oldTypeMetadata != null &&
GlobalDecompilationResultsRepository.Instance.TryGetDecompilationResult(
oldTypeMetadata.AssemblyPath,
oldTypeMetadata.Module.TokenId,
oldTypeMetadata.TokenId,
out result))
{
oldResult = result;
}
if (newTypeMetadata != null &&
GlobalDecompilationResultsRepository.Instance.TryGetDecompilationResult(
newTypeMetadata.AssemblyPath,
newTypeMetadata.Module.TokenId,
newTypeMetadata.TokenId,
out result))
{
newResult = result;
}
var typeNode = new TypeNode(parent, map, new MemberNodeBase[0], oldResult, newResult);
var memberManager = new MemberMergeManager(map);
var members = memberManager.GetMergedCollection().Select <IOldToNewTupleMap <MemberDefinitionMetadataBase>, MemberNodeBase> (
e =>
{
if (e.GetFirstNotNullItem().MemberType == MemberType.Type)
{
return(NestedTypeNode.Create(
typeNode,
new OldToNewTupleMap <TypeMetadata> ((TypeMetadata)e.OldType, (TypeMetadata)e.NewType)));
}
return(new MemberNode(
typeNode,
new OldToNewTupleMap <MemberMetadata> ((MemberMetadata)e.OldType, (MemberMetadata)e.NewType)));
}).ToArray();
typeNode.Members = members;
return(typeNode);
}
protected override void LoadChildren()
{
LoadAPIItemsContext context = this.apiDiffInfo.GenerateLoadAPIItemsContext();
var memberManager = new MemberMergeManager(TypesMap);
ObservableCollection <ItemNodeBase> collection = new ObservableCollection <ItemNodeBase>(memberManager
.GetMergedCollection()
.Where(ApiOnlyFilter)
.Select(tuple => GetItemNodeFromMemberType(tuple, context)));
context.Validate();
DispatcherObjectExt.BeginInvoke(() =>
{
foreach (var item in collection)
{
this.Children.Add(item);
}
this.OnChildrenLoaded();
}, DispatcherPriority.Background);
}
public static NestedTypeNode Create(TypeNode parent, IOldToNewTupleMap <TypeMetadata> map)
{
var nestedTypeNode = new NestedTypeNode(parent, map, new MemberNodeBase[0]);
var memberManager = new MemberMergeManager(map);
var members = memberManager.GetMergedCollection().Select <IOldToNewTupleMap <MemberDefinitionMetadataBase>, MemberNodeBase> (
e =>
{
if (e.GetFirstNotNullItem().MemberType == MemberType.Type)
{
return(Create(
parent,
new OldToNewTupleMap <TypeMetadata> ((TypeMetadata)e.OldType, (TypeMetadata)e.NewType)));
}
return(new MemberNode(
nestedTypeNode,
new OldToNewTupleMap <MemberMetadata> ((MemberMetadata)e.OldType, (MemberMetadata)e.NewType)));
}).ToArray();
nestedTypeNode.Members = members;
return(nestedTypeNode);
}
public void Merge_WhenClassesHaveNoCommonProperties_TheResultIsMepy()
{
// arrange
var sourcePropertyIterator = new Mock<IInstanceMemberIterator<PropertyInfo, PropertySourceTest>>();
sourcePropertyIterator.Setup(p => p.GetEnumerator()).Returns(this.CreateSpecificSourceEnumerator);
var destinationPropertyIterator = new Mock<IInstanceMemberIterator<PropertyInfo, PropertyDestinationTest>>();
destinationPropertyIterator.Setup(p => p.GetEnumerator()).Returns(this.CreateSpecificDestinationEnumerator);
var iteratorFactory = new Mock<IIteratorFactory<PropertyInfo>>();
iteratorFactory.Setup(p => p.CreateSourceIterator<PropertySourceTest>()).Returns(sourcePropertyIterator.Object);
iteratorFactory.Setup(p => p.CreateDestinationIterator<PropertyDestinationTest>()).Returns(destinationPropertyIterator.Object);
// act
var mergeManager = new MemberMergeManager<PropertyInfo>(iteratorFactory.Object, _equalityComparerFactory);
var mergeResult = mergeManager.Merge<PropertySourceTest, PropertyDestinationTest>().Select(p => p.MemberInfo).ToList();
// assert
Assert.Equal(Enumerable.Empty<PropertyInfo>(), mergeResult);
}
