// ReSharper disable once UnusedParameter.Local -- method is just a precondition check private void CheckPathAnchorSet(ItemMatch pathAnchor) { if (pathAnchor == null) { throw new ArgumentException($"First path pattern must be specified with {PathItemAnchorOption}"); } }
public void CompareMatchReturnsResultFromParameterComparer() { var oldParameter = new TestParameterDefinition(); var oldParameters = new List <IParameterDefinition> { oldParameter }.AsReadOnly(); var oldItem = new TestMethodDefinition().Set(x => x.Parameters = oldParameters); var newParameter = new TestParameterDefinition(); var newParameters = new List <IParameterDefinition> { newParameter }.AsReadOnly(); var newItem = oldItem.JsonClone().Set(x => x.Parameters = newParameters); var match = new ItemMatch <IMethodDefinition>(oldItem, newItem); var changeType = Model.Create <SemVerChangeType>(); var message = Guid.NewGuid().ToString(); var result = new ComparisonResult(changeType, oldItem, newItem, message); var results = new[] { result }; var options = ComparerOptions.Default; Service <IParameterComparer>() .CompareMatch( Arg.Is <ItemMatch <IParameterDefinition> >(x => x.OldItem == oldParameter && x.NewItem == newParameter), options).Returns(results); var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().HaveCount(1); actual[0].Should().BeEquivalentTo(result); }
private static void EvaluateDefaultValueChanges( ItemMatch <IParameterDefinition> match, ComparerOptions options, IChangeResultAggregator aggregator) { var oldItem = match.OldItem; var newItem = match.NewItem; if (string.IsNullOrWhiteSpace(oldItem.DefaultValue) && string.IsNullOrWhiteSpace(newItem.DefaultValue) == false) { // A default value has been added, this is technically a feature because the consuming assembly can treat it like an overload var args = new FormatArguments( "{DefinitionType} {Identifier} has added the default value {NewValue}", match.NewItem.FullName, null, newItem.DefaultValue); aggregator.AddElementChangedResult(SemVerChangeType.Feature, match, options.MessageFormatter, args); } else if (string.IsNullOrWhiteSpace(oldItem.DefaultValue) == false && string.IsNullOrWhiteSpace(newItem.DefaultValue)) { // A default value has been removed // This will not be a breaking change for existing applications that happen to use a new binary without recompilation // however it does cause a breaking change for compiling existing applications against this API var args = new FormatArguments( "{DefinitionType} {Identifier} has removed the default value {OldValue}", match.NewItem.FullName, oldItem.DefaultValue, null); aggregator.AddElementChangedResult(SemVerChangeType.Breaking, match, options.MessageFormatter, args); } }
public void CompareMatchDoesNotContinueEvaluationWhenModifierChangeIsBreaking() { var oldItem = new TestMethodDefinition(); var newItem = oldItem.JsonClone(); var match = new ItemMatch <IMethodDefinition>(oldItem, newItem); var options = ComparerOptions.Default; const SemVerChangeType changeType = SemVerChangeType.Breaking; var message = Guid.NewGuid().ToString(); var result = new ComparisonResult(changeType, oldItem, newItem, message); var results = new[] { result }; Service <IMethodModifiersComparer>() .CompareMatch( Arg.Is <ItemMatch <IModifiersElement <MethodModifiers> > >(x => x.OldItem == oldItem && x.NewItem == newItem), options).Returns(results); var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().HaveCount(1); actual[0].Should().BeEquivalentTo(result); Service <IGenericTypeElementComparer>().DidNotReceive() .CompareMatch(Arg.Any <ItemMatch <IGenericTypeElement> >(), Arg.Any <ComparerOptions>()); Service <IParameterComparer>().DidNotReceive() .CompareMatch(Arg.Any <ItemMatch <IParameterDefinition> >(), Arg.Any <ComparerOptions>()); }
public void CompareMatchReturnsEmptyChangesWhenGenericTypeParameterRenamed() { var oldTypeParameters = new List <string> { "T" }.AsReadOnly(); var oldItem = new TestMethodDefinition().Set(x => { x.Name = "Original<T>"; x.RawName = "Original"; x.GenericTypeParameters = oldTypeParameters; }); var newTypeParameters = new List <string> { "V" }.AsReadOnly(); var newItem = oldItem.JsonClone().Set(x => { x.Name = "Original<V>"; x.RawName = "Original"; x.GenericTypeParameters = newTypeParameters; }); var match = new ItemMatch <IMethodDefinition>(oldItem, newItem); var options = ComparerOptions.Default; var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().BeEmpty(); }
protected void Render(IEnumerable <Dependency> edges, ItemMatch innerMatchOrNull, [NotNull] ITargetWriter output, int?labelWidthOrNull, bool withNotOkCt) { IDictionary <Item, IEnumerable <Dependency> > itemsAndDependencies = Dependency.Dependencies2ItemsAndDependencies(edges); var innerAndReachableOuterItems = new HashSet <Item>(itemsAndDependencies.Where(n => ItemMatch.IsMatch(innerMatchOrNull, n.Key)).SelectMany(kvp => new[] { kvp.Key }.Concat(kvp.Value.Select(e => e.UsedItem)))); IEnumerable <Item> sortedItems = MoreOrLessTopologicalSort(edges).Where(n => innerAndReachableOuterItems.Contains(n)); if (sortedItems.Any()) { int m = 0; Dictionary <Item, int> item2Index = sortedItems.ToDictionary(n => n, n => ++ m); IEnumerable <Item> topItems = sortedItems.Where(n => ItemMatch.IsMatch(innerMatchOrNull, n)); int labelWidth = labelWidthOrNull ?? Math.Max(Math.Min(sortedItems.Max(n => n.Name.Length), 30), 4); int colWidth = Math.Max(1 + ("" + edges.Max(e => e.Ct)).Length, // 1+ because of loop prefix 1 + ("" + sortedItems.Count()).Length); // 1+ because of ! or % marker string itemFormat = "{0," + (colWidth - 1) + ":" + Repeat('0', colWidth - 1) + "}"; string ctFormat = "{0}{1," + (colWidth - 1) + ":" + Repeat('#', colWidth) + "}"; Write(output, colWidth, labelWidth, topItems, itemFormat, item2Index, withNotOkCt, sortedItems, ctFormat, itemsAndDependencies); } else { Log.WriteError("No visible items and dependencies found for output"); } }
protected virtual IEnumerable <ComparisonResult> EvaluateMatch(ItemMatch <T> match, ComparerOptions options) { match = match ?? throw new ArgumentNullException(nameof(match)); options = options ?? throw new ArgumentNullException(nameof(options)); return(_comparer.CompareMatch(match, options)); }
public void CompareMatchReturnsBreakingWhenNameChangedWithGenericTypeParameters() { var genericTypeParameters = new List <string> { "T" }.AsReadOnly(); var oldItem = new TestMethodDefinition().Set(x => { x.Name = "Original<T>"; x.RawName = "Original"; x.GenericTypeParameters = genericTypeParameters; }); var newItem = oldItem.JsonClone().Set(x => { x.Name = "Renamed<T>"; x.RawName = "Renamed"; }); var match = new ItemMatch <IMethodDefinition>(oldItem, newItem); var options = ComparerOptions.Default; var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.First().Message.Should().Contain("renamed"); actual.Should().HaveCount(1); actual[0].ChangeType.Should().BeEquivalentTo(SemVerChangeType.Breaking); }
public void CompareReturnsReturnsChangeTypeWhenAtLeastOneItemHidden(bool firstItemVisible, bool secondItemVisible, SemVerChangeType?changeType) { var oldMember = new TestClassDefinition() .Set(x => { x.IsVisible = firstItemVisible; }); var newMember = oldMember.JsonClone() .Set(x => { x.IsVisible = secondItemVisible; }); var match = new ItemMatch <IClassDefinition>(oldMember, newMember); var options = ComparerOptions.Default; var attributeProcessor = Substitute.For <IAttributeMatchProcessor>(); var sut = new Wrapper <IClassDefinition>(attributeProcessor, null); var actual = sut.CompareMatch(match, options).ToList(); _output.WriteResults(actual); if (changeType == null) { actual.Should().BeEmpty(); } else { actual.Should().HaveCount(1); actual[0].ChangeType.Should().Be(changeType); } }
public void CompareMatchEvaluatesMatchWhenBothItemsVisible(bool firstItemVisible, bool secondItemVisible, bool matchEvaluated) { var firstItem = Substitute.For <IClassDefinition>(); var secondItem = Substitute.For <IClassDefinition>(); var result = new ComparisonResult(SemVerChangeType.Breaking, firstItem, secondItem, Guid.NewGuid().ToString()); var match = new ItemMatch <IClassDefinition>(firstItem, secondItem); var options = ComparerOptions.Default; var attributeProcessor = Substitute.For <IAttributeMatchProcessor>(); firstItem.IsVisible.Returns(firstItemVisible); secondItem.IsVisible.Returns(secondItemVisible); var sut = new Wrapper <IClassDefinition>(attributeProcessor, result); var actual = sut.CompareMatch(match, options).ToList(); _output.WriteResults(actual); if (matchEvaluated) { actual.Should().Contain(result); } else { actual.Should().NotContain(result); } }
public void CompareReturnsExpectedResultFromPropertyAccessorAccessModifierComparer() { var oldItem = Model.UsingModule <ConfigurationModule>().Create <TestPropertyAccessorDefinition>().Set(x => { x.IsVisible = true; }); var newItem = Model.UsingModule <ConfigurationModule>().Create <TestPropertyAccessorDefinition>().Set(x => { x.IsVisible = true; }); var match = new ItemMatch <IPropertyAccessorDefinition>(oldItem, newItem); var options = ComparerOptions.Default; var message = Guid.NewGuid().ToString(); var result = new ComparisonResult(SemVerChangeType.Breaking, oldItem, newItem, message); var results = new List <ComparisonResult> { result }; Service <IPropertyAccessorAccessModifiersComparer>() .CompareMatch( Arg.Is <ItemMatch <IAccessModifiersElement <PropertyAccessorAccessModifiers> > >(x => x.OldItem == oldItem && x.NewItem == newItem), options).Returns(results); var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().HaveCount(1); actual.First().OldItem.Should().Be(oldItem); actual.First().NewItem.Should().Be(newItem); actual.First().Message.Should().Be(message); actual.First().ChangeType.Should().Be(SemVerChangeType.Breaking); }
public void CanCreateWithMatches() { var oldItem = new TestClassDefinition(); var newItem = new TestClassDefinition(); var matchingItem = new ItemMatch <IClassDefinition>(oldItem, newItem); var matchingItems = new List <ItemMatch <IClassDefinition> > { matchingItem }; var removedItem = new TestClassDefinition(); var removedItems = new List <IClassDefinition> { removedItem }; var addedItem = new TestClassDefinition(); var addedItems = new List <IClassDefinition> { addedItem }; var sut = new MatchResults <IClassDefinition>(matchingItems, removedItems, addedItems); sut.MatchingItems.Should().BeEquivalentTo(matchingItems); sut.ItemsRemoved.Should().BeEquivalentTo(removedItems); sut.ItemsAdded.Should().BeEquivalentTo(addedItems); }
public void CompareReturnsEmptyWhenReturnTypeIsRenamedGenericTypeOnParentType() { var oldGrandparent = new TestClassDefinition().Set(x => x.GenericTypeParameters = new List <string> { "TOld" }.AsReadOnly()); var oldParent = new TestClassDefinition().Set(x => x.DeclaringType = oldGrandparent); var oldMember = new TestMethodDefinition().Set(x => { x.DeclaringType = oldParent; x.ReturnType = "TOld"; }); var newGrandparent = new TestClassDefinition().Set(x => x.GenericTypeParameters = new List <string> { "TNew" }.AsReadOnly()); var newParent = new TestClassDefinition().Set(x => x.DeclaringType = newGrandparent); var newMember = new TestMethodDefinition().Set(x => { x.DeclaringType = newParent; x.ReturnType = "TNew"; }); var match = new ItemMatch <TestMethodDefinition>(oldMember, newMember); var options = ComparerOptions.Default; var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().BeEmpty(); }
public void CompareReturnsBreakingWhenReturnTypeIsChangedAndParentTypesExist() { var oldGrandparent = new TestClassDefinition().Set(x => x.GenericTypeParameters = new List <string> { "TOld" }.AsReadOnly()); var oldParent = new TestClassDefinition().Set(x => x.DeclaringType = oldGrandparent); var oldMember = new TestMethodDefinition().Set(x => { x.DeclaringType = oldParent; x.ReturnType = "string"; }); var newGrandparent = new TestClassDefinition().Set(x => x.GenericTypeParameters = new List <string> { "TNew" }.AsReadOnly()); var newParent = new TestClassDefinition().Set(x => x.DeclaringType = newGrandparent); var newMember = new TestMethodDefinition().Set(x => { x.DeclaringType = newParent; x.ReturnType = "DateTime"; }); var match = new ItemMatch <TestMethodDefinition>(oldMember, newMember); var options = ComparerOptions.Default; var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().NotBeEmpty(); actual[0].ChangeType.Should().Be(SemVerChangeType.Breaking); }
public Projection([CanBeNull] ItemType sourceItemTypeOrNull, [NotNull] ItemType targetItemType, [NotNull] string pattern, [CanBeNull] string[] targetSegments, bool ignoreCase, bool forLeftSide, bool forRightSide, string source = null) { if (targetSegments != null) { if (targetSegments.Length > targetItemType.Length) { Log.WriteError($"Targettype {targetItemType.Name} has {targetItemType.Length} segments, but {targetSegments.Length} are defined in projection: {string.Join(",", targetSegments)}"); throw new ArgumentException("targetSegments length != targetItemType.Length", nameof(targetSegments)); } else if (targetSegments.Length < targetItemType.Length) { targetSegments = targetSegments.Concat(Enumerable.Range(1, targetItemType.Length - targetSegments.Length).Select(i => "")) .ToArray(); } if (targetSegments.Any(s => s == null)) { throw new ArgumentException("targetSegments contains null", nameof(targetSegments)); } } else { targetSegments = Enumerable.Range(1, targetItemType.Length).Select(i => "\\" + i).ToArray(); } _targetItemType = targetItemType; _targetSegments = targetSegments; Source = source; _forLeftSide = forLeftSide; _forRightSide = forRightSide; ItemMatch = new ItemMatch(sourceItemTypeOrNull, pattern, 0, ignoreCase, anyWhereMatcherOk: false); }
public void ShouldReturnCompleteMatchesFirstDueToMatching() { var incompleteMatch = new ItemMatch <LocalTestResource, RemoteTestResource>( null, new RemoteTestResource(1, "complete")); var completeMatch = new ItemMatch <LocalTestResource, RemoteTestResource>( new LocalTestResource(2, 10), new RemoteTestResource(2, "complete")); var matches = new List <ItemMatch <LocalTestResource, RemoteTestResource> > { incompleteMatch, completeMatch }; var localTestResource = new LocalTestResource(1, 10); _channelConfig.Type1EndpointConfiguration.Endpoint.Create(localTestResource); var resultMatches = matches.BatchCompleteItems(_channelConfig, TargetType.T1).ToList(); Assert.AreEqual(2, resultMatches.Count); Assert.AreEqual(completeMatch, resultMatches[0]); Assert.AreEqual(incompleteMatch.Result2, resultMatches[1].Result2); Assert.AreEqual(localTestResource, resultMatches[1].Result1); }
private static bool EvaluateArgumentCount(ItemMatch <IAttributeDefinition> match, ComparerOptions options, IChangeResultAggregator aggregator) { var oldArguments = match.OldItem.Arguments.Count; var newArguments = match.NewItem.Arguments.Count; var argumentShift = oldArguments - newArguments; if (argumentShift != 0) { // One or more arguments have been added or removed var changeLabel = argumentShift > 0 ? "removed" : "added"; var shiftAmount = Math.Abs(argumentShift); var suffix = shiftAmount == 1 ? "" : "s"; var args = new FormatArguments( $"{{DefinitionType}} {{Identifier}} has {changeLabel} {shiftAmount} argument{suffix}", match.NewItem.Name, null, null); aggregator.AddElementChangedResult(SemVerChangeType.Breaking, match, options.MessageFormatter, args); // No need to look into how the attribute has changed return(true); } return(false); }
private static void EvaluateArgumentDefinitionChanges( ItemMatch <IAttributeDefinition> match, ComparerOptions options, IChangeResultAggregator aggregator) { if (EvaluateArgumentCount(match, options, aggregator)) { return; } if (EvaluateOrdinalArgumentCount(match, options, aggregator)) { return; } // No need to check for a difference in named argument counts because at this point we have the same number of overall arguments and the same number of ordinal arguments // The number of named arguments must be the same // At this point we have the same number of ordinal and named arguments if (EvaluateOrdinalArgument(match, options, aggregator)) { return; } EvaluateNamedArgument(match, options, aggregator); }
public void CompareMatchReturnsBreakingWhenGenericTypeParameterAddedWithGenericConstraints() { var parameters = new List <string> { "T" }.AsReadOnly(); var constraintList = new TestConstraintListDefinition { Name = "T", Constraints = new List <string> { "struct", "Enum" }.AsReadOnly() }; var constraints = new List <IConstraintListDefinition> { constraintList }.AsReadOnly(); var oldItem = new TestClassDefinition(); var newItem = new TestClassDefinition().Set(x => { x.GenericTypeParameters = parameters; x.GenericConstraints = constraints; }); var match = new ItemMatch <IGenericTypeElement>(oldItem, newItem); var options = ComparerOptions.Default; var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().HaveCount(1); actual[0].ChangeType.Should().Be(SemVerChangeType.Breaking); actual[0].Message.Should().Contain("added"); }
private static bool EvaluateOrdinalArgument(ItemMatch <IAttributeDefinition> match, ComparerOptions options, IChangeResultAggregator aggregator) { var oldArguments = match.OldItem.Arguments.Where(x => x.ArgumentType == ArgumentType.Ordinal).ToList(); var newArguments = match.NewItem.Arguments.Where(x => x.ArgumentType == ArgumentType.Ordinal).ToList(); for (var index = 0; index < oldArguments.Count; index++) { var oldArgument = oldArguments[index]; var newArgument = newArguments[index]; if (oldArgument.Value != newArgument.Value) { var args = new FormatArguments( "{DefinitionType} {Identifier} has changed value from {OldValue} to {NewValue}", (index + 1).ToString(), oldArgument.Value, newArgument.Value); // Create a match for the arguments var argumentMatch = new ItemMatch <IArgumentDefinition>(oldArgument, newArgument); aggregator.AddElementChangedResult(SemVerChangeType.Breaking, argumentMatch, options.MessageFormatter, args); return(true); } } return(false); }
public void CompareMatchReturnsEmptyWhenGenericTypeConstraintsMatch() { var parameters = new List <string> { "T" }.AsReadOnly(); var constraintList = new TestConstraintListDefinition { Name = "T", Constraints = new List <string> { "struct", "Enum" }.AsReadOnly() }; var constraints = new List <IConstraintListDefinition> { constraintList }.AsReadOnly(); var oldItem = new TestClassDefinition().Set(x => { x.GenericTypeParameters = parameters; x.GenericConstraints = constraints; }); var newItem = new TestClassDefinition().Set(x => { x.GenericTypeParameters = parameters; x.GenericConstraints = constraints; }); var match = new ItemMatch <IGenericTypeElement>(oldItem, newItem); var options = ComparerOptions.Default; var actual = SUT.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().BeEmpty(); }
/// <summary> /// Desfaz um match realizado /// </summary> /// <param name="id">Id do match</param> /// <param name="statusCode">Variável de saída StatusCode de resposta</param> /// <param name="dadosRetorno">Variável de saída de mensagem de retorno</param> public void DesfazerMatch(Guid id, out int statusCode, out object dadosRetorno) { // Validando match ItemMatch match = _matchDomain.ObterPorId(id); if (match == null) { statusCode = StatusCodes.Status400BadRequest; dadosRetorno = new { Sucesso = false, Mensagem = $"O match de id {id.ToString()} não foi encontrado" }; } else { _matchDomain.Excluir(id); _uow.Efetivar(); statusCode = StatusCodes.Status200OK; dadosRetorno = new { Sucesso = true, Mensagem = $"Match excluído com sucesso" }; } }
public void CompareMatchReturnsBreakingWhenOrdinalArgumentValueChanged() { var oldArgument = Model.UsingModule <ConfigurationModule>().Create <TestArgumentDefinition>() .Set(x => x.ArgumentType = ArgumentType.Ordinal); var oldArguments = new[] { oldArgument }; var oldAttribute = Model.UsingModule <ConfigurationModule>().Create <TestAttributeDefinition>() .Set(x => x.Arguments = oldArguments); var newArgument = Model.UsingModule <ConfigurationModule>().Create <TestArgumentDefinition>().Set( x => { x.ArgumentType = ArgumentType.Ordinal; }); var newArguments = new[] { newArgument }; var newAttribute = Model.UsingModule <ConfigurationModule>().Create <TestAttributeDefinition>() .Set(x => x.Arguments = newArguments); var match = new ItemMatch <IAttributeDefinition>(oldAttribute, newAttribute); var options = OptionsFactory.BuildOptions(); var sut = new AttributeComparer(); var actual = sut.CompareMatch(match, options).ToList(); _output.WriteResults(actual); actual.Should().HaveCount(1); actual[0].ChangeType.Should().Be(SemVerChangeType.Breaking); actual[0].OldItem.Should().BeAssignableTo <IArgumentDefinition>(); actual[0].NewItem.Should().BeAssignableTo <IArgumentDefinition>(); }
public IEnumerable <ComparisonResult> CompareMatch( ItemMatch <IAccessModifiersElement <T> > match, ComparerOptions options) { var convertedMatch = new ItemMatch <IElementDefinition>(match.OldItem, match.NewItem); return(CompareMatch(convertedMatch, match.OldItem.AccessModifiers, match.NewItem.AccessModifiers, options)); }
public bool Matches([CanBeNull] IEnumerable <Dependency> incoming, Item i, [CanBeNull] IEnumerable <Dependency> outgoing) { return((_atLeastOneIncomingDependencyPattern == null || incoming != null && incoming.Any(d => _atLeastOneIncomingDependencyPattern.IsMatch(d))) && ItemMatch.IsMatch(_itemMatch, i) && (_atLeastOneOutgoingDependencyPattern == null || outgoing != null && outgoing.Any(d => _atLeastOneOutgoingDependencyPattern.IsMatch(d)))); }
private void MatchFound(T oldItem, T newItem) { var match = new ItemMatch <T>(oldItem, newItem); _matches.Add(match); _oldItems.Remove(oldItem); _newItems.Remove(newItem); }
public void ShouldReturnAlreadyCompleteMatches() { var itemMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( new LocalTestResource(1, 10), new RemoteTestResource(1, "test")); var result = _itemMatcherUnderTest.AppendIndividualItem(itemMatch); Assert.AreEqual(itemMatch, result); }
public void ShouldReturnSourceWhenReallyNoOppositeT1() { var testMatch = new ItemMatch <LocalTestResource, RemoteTestResource>( null, new RemoteTestResource(1, "Missing")); var resultMatch = _matcherUnderTest.Complete(testMatch); Assert.IsNull(resultMatch.Result1); }
/// <summary> /// Add one or more <c>DependencyRules</c>s from a single input line. /// public for testability. /// </summary> public bool AddDependencyRules([CanBeNull] ItemType usingItemTypeHint, [CanBeNull] ItemType usedItemTypeHint, [NotNull] string ruleSourceName, int lineNo, [NotNull] string line, bool ignoreCase, [NotNull] string previousRawUsingPattern, [NotNull] out string rawTrimmedUsingPattern) { Match match; if (TryMatch(line, "^(.*)--(.*)->(.*)", out match)) { rawTrimmedUsingPattern = GetUsingPattern(match.Groups[1].Value, previousRawUsingPattern); IEnumerable <DependencyRule> rules = CreateDependencyRules(usingItemTypeHint, usedItemTypeHint, ruleSourceName, lineNo, rawTrimmedUsingPattern, match.Groups[2].Value, match.Groups[3].Value, "--", "->", questionableRule: false, ignoreCase: ignoreCase); _allowed.AddRange(rules); return(true); } else if (TryMatch(line, "^(.*)--(.*)-[?](.*)", out match)) { rawTrimmedUsingPattern = GetUsingPattern(match.Groups[1].Value, previousRawUsingPattern); IEnumerable <DependencyRule> rules = CreateDependencyRules(usingItemTypeHint, usedItemTypeHint, ruleSourceName, lineNo, rawTrimmedUsingPattern, match.Groups[2].Value, match.Groups[3].Value, "--", "-?", questionableRule: true, ignoreCase: ignoreCase); _questionable.AddRange(rules); return(true); } else if (TryMatch(line, "^(.*)--(.*)-!(.*)", out match)) { rawTrimmedUsingPattern = GetUsingPattern(match.Groups[1].Value, previousRawUsingPattern); IEnumerable <DependencyRule> rules = CreateDependencyRules(usingItemTypeHint, usedItemTypeHint, ruleSourceName, lineNo, rawTrimmedUsingPattern, match.Groups[2].Value, match.Groups[3].Value, "--", "-!", questionableRule: false, ignoreCase: ignoreCase); _forbidden.AddRange(rules); return(true); } else if (TryMatch(line, "^(.*)===>(.*)", out match)) { rawTrimmedUsingPattern = GetUsingPattern(match.Groups[1].Value, previousRawUsingPattern); string rawTrimmedUsedPattern = match.Groups[2].Value.Trim(); { ItemMatch @using = new ItemMatch(usingItemTypeHint, rawTrimmedUsingPattern, 0, ignoreCase, anyWhereMatcherOk: false); CopyRulesWithNewUsing(rawTrimmedUsingPattern, rawTrimmedUsedPattern, _allowed, @using, ruleSourceName, lineNo, line); CopyRulesWithNewUsing(rawTrimmedUsingPattern, rawTrimmedUsedPattern, _questionable, @using, ruleSourceName, lineNo, line); CopyRulesWithNewUsing(rawTrimmedUsingPattern, rawTrimmedUsedPattern, _forbidden, @using, ruleSourceName, lineNo, line); } // using may also use the right side of ===>; in other words, ===> is an implicit --->. _allowed.AddRange(CreateDependencyRules(usingItemTypeHint, usedItemTypeHint, ruleSourceName, lineNo, rawTrimmedUsingPattern, "", rawTrimmedUsedPattern, "==", "=>", questionableRule: false, ignoreCase: ignoreCase)); return(true); } else { throw new ApplicationException("Unexpected rule at " + ruleSourceName + ":" + lineNo); } }
public void ShouldReturnSourceWhenReallyNoOppositeT1() { var testMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( null, new RemoteTestResource(1, "Missing")); var resultMatch = _matcherUnderTest.Complete(testMatch); Assert.IsNull(resultMatch.Result1); }
public IEnumerable <ComparisonResult> CompareMatch(ItemMatch <ITypeDefinition> match, ComparerOptions options) { match = match ?? throw new ArgumentNullException(nameof(match)); options = options ?? throw new ArgumentNullException(nameof(options)); // Check for a change in type if (match.OldItem.GetType() != match.NewItem.GetType()) { var newType = DetermineTypeChangeDescription(match.NewItem); var args = new FormatArguments( "{DefinitionType} {Identifier} has changed to {NewValue}", match.OldItem.FullName, null, newType); var message = options.MessageFormatter.FormatItemChangedMessage(match, args); var result = new ComparisonResult( SemVerChangeType.Breaking, match.OldItem, match.NewItem, message); // We are not going to process any other changes return(new[] { result }); } if (match.OldItem is IClassDefinition oldClass && match.NewItem is IClassDefinition newClass) { var itemMatch = new ItemMatch <IClassDefinition>(oldClass, newClass); return(_classComparer.CompareMatch(itemMatch, options)); } if (match.OldItem is IStructDefinition oldStruct && match.NewItem is IStructDefinition newStruct) { var itemMatch = new ItemMatch <IStructDefinition>(oldStruct, newStruct); return(_structComparer.CompareMatch(itemMatch, options)); } if (match.OldItem is IInterfaceDefinition oldInterface && match.NewItem is IInterfaceDefinition newInterface) { var itemMatch = new ItemMatch <IInterfaceDefinition>(oldInterface, newInterface); return(_interfaceComparer.CompareMatch(itemMatch, options)); } throw new NotSupportedException( $"There is no {nameof(ITypeComparer<ITypeDefinition>)} implementation for {match.OldItem.GetType()}"); }
private static ItemMatch <CatalogItemUnion> GetMatch <TItem>(ItemMatch <TItem> original, CatalogItemUnion union) { return(new( original.Key, original.KeyStrength, union, original.ItemStrengthMultiplier, original.MatchStrength)); }
public void ShouldReturnOriginalMatchWhenT1NotAvailable() { var itemMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( null, new RemoteTestResource(1, "test")); var result = _itemMatcherUnderTest.AppendIndividualItem(itemMatch); Assert.AreEqual(itemMatch, result); }
public void ShouldReturnOriginalMatchWhenT2NotAvailable() { var itemMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( new LocalTestResource(1, 10), null); var result = _itemMatcherUnderTest.AppendIndividualItem(itemMatch, TargetType.T2); Assert.AreEqual(itemMatch, result); }
public void ShouldReturnSourceWhenReallyNoOppositeT2() { _completionSourceType = TargetType.T2; ConstructTestSubject(); var testMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( new LocalTestResource(1), null); var resultMatch = _matcherUnderTest.Complete(testMatch); Assert.IsNull(resultMatch.Result2); }
public void ShouldAppendT2WhenDefaultButAvailable() { var itemMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( new LocalTestResource(1, 10), null); var item2 = new RemoteTestResource(1, "test"); _channelConfig.Type2EndpointConfiguration.Endpoint.Create(item2); var result = _itemMatcherUnderTest.AppendIndividualItem(itemMatch, TargetType.T2); Assert.AreEqual(item2, result.Result2); Assert.AreEqual(itemMatch.Result1, result.Result1); }
public void ShouldTryMatchFromGivenSourceType2() { _completionSourceType = TargetType.T2; ConstructTestSubject(); var remoteTestResource = new RemoteTestResource(1, "test"); _channelConfiguration.Type2EndpointConfiguration.Endpoint.Create(remoteTestResource); var testMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( new LocalTestResource(1, 10), null); var resultMatch = _matcherUnderTest.Complete(testMatch); Assert.IsNotNull(resultMatch.Result2); Assert.AreEqual(remoteTestResource, resultMatch.Result2); }
public void ShouldTryMatchFromGivenSourceType1() { // Add resource that should be retrieved by matcher var localTestResource = new LocalTestResource(1, 10); _channelConfiguration.Type1EndpointConfiguration.Endpoint.Create(localTestResource); var testMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( null, new RemoteTestResource(1, "Missing")); var resultMatch = _matcherUnderTest.Complete(testMatch); Assert.IsNotNull(resultMatch.Result1); Assert.AreEqual(localTestResource, resultMatch.Result1); }
public void ShouldReturnCompleteMatchesFirstDueToMatching() { var incompleteMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( null, new RemoteTestResource(1, "complete")); var completeMatch = new ItemMatch<LocalTestResource, RemoteTestResource>( new LocalTestResource(2, 10), new RemoteTestResource(2, "complete")); var matches = new List<ItemMatch<LocalTestResource, RemoteTestResource>> { incompleteMatch, completeMatch }; var localTestResource = new LocalTestResource(1, 10); _channelConfig.Type1EndpointConfiguration.Endpoint.Create(localTestResource); var resultMatches = matches.BatchCompleteItems(_channelConfig, TargetType.T1).ToList(); Assert.AreEqual(2, resultMatches.Count); Assert.AreEqual(completeMatch, resultMatches[0]); Assert.AreEqual(incompleteMatch.Result2, resultMatches[1].Result2); Assert.AreEqual(localTestResource, resultMatches[1].Result1); }