public void FindMatchesReturnsMatchWhenTypesHaveSameSignatures()
{
var oldItem = new TestClassDefinition();
var newItem = new TestClassDefinition().Set(x =>
{
x.RawName = oldItem.RawName;
x.Namespace = oldItem.Namespace;
});
var oldItems = new List <ITypeDefinition>
{
oldItem
};
var newItems = new List <ITypeDefinition>
{
newItem
};
var sut = new TypeEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsRemoved.Should().BeEmpty();
actual.ItemsAdded.Should().BeEmpty();
actual.MatchingItems.Should().HaveCount(1);
var match = actual.MatchingItems.First();
match.OldItem.Should().Be(oldItem);
match.NewItem.Should().Be(newItem);
}
public void FindMatchesDoesNotReturnMatchWhenDeclaringTypesAreDifferent()
{
var oldParent = new TestClassDefinition();
var newParent = new TestClassDefinition();
var oldItem = new TestClassDefinition().Set(x => x.DeclaringType = oldParent);
var newItem = new TestClassDefinition().Set(x =>
{
x.RawName = oldItem.RawName;
x.Namespace = oldItem.Namespace;
x.DeclaringType = newParent;
});
var oldItems = new List <ITypeDefinition>
{
oldItem
};
var newItems = new List <ITypeDefinition>
{
newItem
};
var sut = new TypeEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsRemoved.Should().BeEquivalentTo(oldItems);
actual.ItemsAdded.Should().BeEquivalentTo(newItems);
actual.MatchingItems.Should().BeEmpty();
}
public void FindMatchesReturnsMatchOnMovedTypeWithDeclaringTypes()
{
var oldParent = new TestClassDefinition();
var newParent = new TestClassDefinition().Set(x => { x.RawName = oldParent.RawName; });
var oldItem = new TestClassDefinition().Set(x => x.DeclaringType = oldParent);
var newItem = new TestClassDefinition().Set(x =>
{
x.RawName = oldItem.RawName;
x.DeclaringType = newParent;
});
var oldItems = new List <ITypeDefinition>
{
oldItem
};
var newItems = new List <ITypeDefinition>
{
newItem
};
var sut = new TypeEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsRemoved.Should().BeEmpty();
actual.ItemsAdded.Should().BeEmpty();
actual.MatchingItems.Should().HaveCount(1);
var match = actual.MatchingItems.First();
match.OldItem.Should().Be(oldItem);
match.NewItem.Should().Be(newItem);
}
public void FindMatchesDoesNotReturnMatchOnMovedTypeWhenGenericTypeCountsAreDifferent()
{
var oldItem = new TestClassDefinition();
var newItem = new TestClassDefinition().Set(x =>
{
x.RawName = oldItem.RawName;
var updatedGenericTypeParameters = new List <string>(x.GenericTypeParameters)
{
Guid.NewGuid().ToString()
};
x.GenericTypeParameters = updatedGenericTypeParameters.AsReadOnly();
});
var oldItems = new List <ITypeDefinition>
{
oldItem
};
var newItems = new List <ITypeDefinition>
{
newItem
};
var sut = new TypeEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsRemoved.Should().BeEquivalentTo(oldItems);
actual.ItemsAdded.Should().BeEquivalentTo(newItems);
actual.MatchingItems.Should().BeEmpty();
}
public void FindMatchesDoesNotReturnMatchWhenNoItemsAddedOrRemoved()
{
var oldItems = Array.Empty <ITypeDefinition>();
var newItems = Array.Empty <ITypeDefinition>();
var sut = new TypeEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsRemoved.Should().BeEmpty();
actual.ItemsAdded.Should().BeEmpty();
actual.MatchingItems.Should().BeEmpty();
}
/// <summary>
/// Tries to find a class.
/// </summary>
/// <returns> <c>true</c> if something was found; otherwise, <c>false</c> . </returns>
/// <param name='result'> Result. </param>
/// <param name='evaluator'> A type evaluator delegate </param>
/// <typeparam name='T'> The interface type of the plugin. </typeparam>
public static Boolean TryFind <T>(out T result, TypeEvaluator evaluator)
{
foreach (var aPluginTypeOfT in GetAllTypes <T>(false).Where(_ => evaluator(_)))
{
var aPluginInstance = Activator.CreateInstance(aPluginTypeOfT);
if (aPluginInstance != null)
{
result = (T)aPluginInstance;
return(true);
}
}
result = default(T);
return(false);
}
public void FindMatchesDoesNotReturnMatchWhenNamespaceAndRawNameAreDifferent()
{
var oldItem = new TestClassDefinition();
var newItem = new TestClassDefinition();
var oldItems = new List <ITypeDefinition>
{
oldItem
};
var newItems = new List <ITypeDefinition>
{
newItem
};
var sut = new TypeEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsRemoved.Should().BeEquivalentTo(oldItems);
actual.ItemsAdded.Should().BeEquivalentTo(newItems);
actual.MatchingItems.Should().BeEmpty();
}
public void FindMatchesDoesNotReturnMatchWhenMultipleNewItemsMatchAsPossibleMovedType()
{
var oldItem = new TestClassDefinition();
var newItem = new TestClassDefinition().Set(x => { x.RawName = oldItem.RawName; });
var otherNewItem = new TestClassDefinition().Set(x => { x.RawName = oldItem.RawName; });
var oldItems = new List <ITypeDefinition>
{
oldItem
};
var newItems = new List <ITypeDefinition>
{
newItem,
otherNewItem
};
var sut = new TypeEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsRemoved.Should().BeEquivalentTo(oldItems);
actual.ItemsAdded.Should().BeEquivalentTo(newItems);
actual.MatchingItems.Should().BeEmpty();
}
public static IChangeCalculator BuildCalculator(ILogger?logger)
{
var attributeComparer = new AttributeComparer();
var attributeMatcher = new AttributeEvaluator();
var attributeProcessor = new AttributeMatchProcessor(attributeMatcher, attributeComparer, logger);
var accessModifierChangeTable = new AccessModifiersChangeTable();
var accessModifiersComparer = new AccessModifiersComparer(accessModifierChangeTable);
var memberModifiersChangeTable = new PropertyModifiersChangeTable();
var memberModifiersComparer = new PropertyModifiersComparer(memberModifiersChangeTable);
var genericTypeElementComparer = new GenericTypeElementComparer();
var fieldModifiersChangeTable = new FieldModifiersChangeTable();
var fieldModifiersComparer = new FieldModifiersComparer(fieldModifiersChangeTable);
var fieldComparer = new FieldComparer(accessModifiersComparer, fieldModifiersComparer, attributeProcessor);
var fieldMatcher = new FieldEvaluator();
var fieldProcessor = new FieldMatchProcessor(fieldMatcher, fieldComparer, logger);
var propertyAccessorAccessModifiersChangeTable = new PropertyAccessorAccessModifiersChangeTable();
var propertyAccessorAccessModifiersComparer = new PropertyAccessorAccessModifiersComparer(propertyAccessorAccessModifiersChangeTable);
var propertyAccessorComparer = new PropertyAccessorComparer(propertyAccessorAccessModifiersComparer, attributeProcessor);
var propertyAccessorEvaluator = new PropertyAccessorEvaluator();
var propertyAccessorProcessor =
new PropertyAccessorMatchProcessor(propertyAccessorEvaluator, propertyAccessorComparer, logger);
var propertyComparer = new PropertyComparer(accessModifiersComparer, memberModifiersComparer, propertyAccessorProcessor, attributeProcessor);
var propertyMatcher = new PropertyEvaluator();
var propertyProcessor = new PropertyMatchProcessor(propertyMatcher, propertyComparer, logger);
var methodEvaluator = new MethodEvaluator();
var methodModifiersChangeTable = new MethodModifiersChangeTable();
var methodModifiersComparer = new MethodModifiersComparer(methodModifiersChangeTable);
var parameterModifiersChangeTable = new ParameterModifiersChangeTable();
var parameterModifiersComparer = new ParameterModifiersComparer(parameterModifiersChangeTable);
var parameterComparer = new ParameterComparer(parameterModifiersComparer, attributeProcessor);
var methodComparer = new MethodComparer(accessModifiersComparer, methodModifiersComparer, genericTypeElementComparer, parameterComparer, attributeProcessor);
var methodProcessor = new MethodMatchProcessor(methodEvaluator, methodComparer, logger);
var classModifiersChangeTable = new ClassModifiersChangeTable();
var classModifiersComparer = new ClassModifiersComparer(classModifiersChangeTable);
var classComparer = new ClassComparer(
accessModifiersComparer,
classModifiersComparer,
genericTypeElementComparer,
fieldProcessor,
propertyProcessor,
methodProcessor, attributeProcessor);
var interfaceComparer = new InterfaceComparer(
accessModifiersComparer,
genericTypeElementComparer,
propertyProcessor,
methodProcessor,
attributeProcessor);
var structModifiersChangeTable = new StructModifiersChangeTable();
var structModifiersComparer = new StructModifiersComparer(structModifiersChangeTable);
var structComparer = new StructComparer(
accessModifiersComparer,
structModifiersComparer,
genericTypeElementComparer,
fieldProcessor,
propertyProcessor,
methodProcessor,
attributeProcessor);
var aggregateTypeComparer = new AggregateTypeComparer(classComparer, interfaceComparer, structComparer);
var typeEvaluator = new TypeEvaluator();
var typeProcessor = new TypeMatchProcessor(typeEvaluator, aggregateTypeComparer, logger);
return(new ChangeCalculator(typeProcessor, logger));
}
