Remove complexity and make IncrementStrategy non-nullable

HHobeck · HHobeck · commit 7ffc693ea394 · 2023-02-27T10:04:44.000+01:00
diff --git a/src/GitVersion.Core.Tests/Configuration/ConfigurationProviderTests.CanWriteOutEffectiveConfiguration.approved.txt b/src/GitVersion.Core.Tests/Configuration/ConfigurationProviderTests.CanWriteOutEffectiveConfiguration.approved.txt
@@ -118,7 +118,7 @@ ignore:
   sha: []
 mode: ContinuousDelivery
 label: '{BranchName}'
-increment: Patch
+increment: Inherit
 prevent-increment-of-merged-branch-version: false
 track-merge-target: false
 track-merge-message: true
diff --git a/src/GitVersion.Core.Tests/Configuration/Init/InitScenarios.CanSetNextVersion.approved.txt b/src/GitVersion.Core.Tests/Configuration/Init/InitScenarios.CanSetNextVersion.approved.txt
@@ -5,3 +5,4 @@ semantic-version-format: Strict
 branches: {}
 ignore:
   sha: []
+increment: Inherit
diff --git a/src/GitVersion.Core.Tests/IntegrationTests/MainlineDevelopmentMode.cs b/src/GitVersion.Core.Tests/IntegrationTests/MainlineDevelopmentMode.cs
@@ -443,11 +443,11 @@ public void VerifyIncrementConfigIsHonoured()
             .WithIncrement(IncrementStrategy.Minor)
             .WithBranch("main", builder => builder
                 .WithVersioningMode(VersioningMode.Mainline)
-                .WithIncrement(null)
+                .WithIncrement(IncrementStrategy.Inherit)
             )
             .WithBranch("feature", builder => builder
                 .WithVersioningMode(VersioningMode.Mainline)
-                .WithIncrement(null)
+                .WithIncrement(IncrementStrategy.Inherit)
             )
             .Build();
 
diff --git a/src/GitVersion.Core.Tests/IntegrationTests/VersionInCurrentBranchNameScenarios.cs b/src/GitVersion.Core.Tests/IntegrationTests/VersionInCurrentBranchNameScenarios.cs
@@ -52,7 +52,7 @@ public void TakesVersionFromNameOfRemoteReleaseBranchInOrigin()
     }
 
     [Test]
-    public void DoesNotTakeVersionFromNameOfRemoteReleaseBranchInCustomRemote()
+    public void TakesVersionFromNameOfRemoteReleaseBranchInCustom()
     {
         using var fixture = new RemoteRepositoryFixture();
         fixture.LocalRepositoryFixture.Repository.Network.Remotes.Rename("origin", "upstream");
@@ -62,6 +62,6 @@ public void DoesNotTakeVersionFromNameOfRemoteReleaseBranchInCustomRemote()
 
         fixture.LocalRepositoryFixture.Checkout("upstream/release/2.0.0");
 
-        fixture.LocalRepositoryFixture.AssertFullSemver("0.0.0-beta.1+6"); // This test fails with 2.0.0-beta.1+1
+        fixture.LocalRepositoryFixture.AssertFullSemver("2.0.0-beta.1+1");
     }
 }
diff --git a/src/GitVersion.Core.Tests/VersionCalculation/EffectiveBranchConfigurationFinderTests.cs b/src/GitVersion.Core.Tests/VersionCalculation/EffectiveBranchConfigurationFinderTests.cs
@@ -200,28 +200,7 @@ public void UsesFirstBranchConfigWhenMultipleMatch(string branchName, IncrementS
     }
 
     [Test]
-    public void When_getting_configurations_of_an_orphaned_branch_Given_fallback_configuaration_without_increment_Then_result_should_be_empty()
-    {
-        // Arrange
-        var branchMock = GitToolsTestingExtensions.CreateMockBranch("develop", GitToolsTestingExtensions.CreateMockCommit());
-        var configuration = GitFlowConfigurationBuilder.New
-            .WithIncrement(null)
-            .WithBranch("develop", builder => builder.WithIncrement(IncrementStrategy.Inherit))
-            .Build();
-        var repositoryStoreMock = Substitute.For<IRepositoryStore>();
-        repositoryStoreMock.GetSourceBranches(branchMock, configuration, Arg.Any<HashSet<IBranch>>()).Returns(Enumerable.Empty<IBranch>());
-
-        var unitUnderTest = new EffectiveBranchConfigurationFinder(Substitute.For<ILog>(), repositoryStoreMock);
-
-        // Act
-        var actual = unitUnderTest.GetConfigurations(branchMock, configuration).ToArray();
-
-        // Assert
-        actual.ShouldBeEmpty();
-    }
-
-    [Test]
-    public void When_getting_configurations_of_an_orphaned_branch_Given_fallback_configuration_with_increment_inherit_Then_result_should_have_increment_none()
+    public void When_getting_configurations_of_an_orphaned_branch_Given_fallback_configuration_with_increment_inherit_Then_result_should_be_empty()
     {
         // Arrange
         var branchMock = GitToolsTestingExtensions.CreateMockBranch("develop", GitToolsTestingExtensions.CreateMockCommit());
@@ -238,9 +217,7 @@ public void When_getting_configurations_of_an_orphaned_branch_Given_fallback_con
         var actual = unitUnderTest.GetConfigurations(branchMock, configuration).ToArray();
 
         // Assert
-        actual.ShouldHaveSingleItem();
-        actual[0].Branch.ShouldBe(branchMock);
-        actual[0].Value.Increment.ShouldBe(IncrementStrategy.None);
+        actual.ShouldBeEmpty();
     }
 
     [TestCase(IncrementStrategy.None)]
@@ -271,12 +248,13 @@ public void When_getting_configurations_of_an_orphaned_branch_Given_fallback_con
     }
 
     [Test]
-    public void When_getting_configurations_of_an_unknown_branch_Given_fallback_configuaration_without_increment_and_unknown_configuration_with_increment_inherit_Then_result_should_be_empty()
+    public void When_getting_configurations_of_an_unknown_branch_Given_fallback_and_unknown_configuration_with_increment_inherit_Then_result_should_be_empty()
     {
         // Arrange
         var branchMock = GitToolsTestingExtensions.CreateMockBranch("unknown", GitToolsTestingExtensions.CreateMockCommit());
         var configuration = GitFlowConfigurationBuilder.New
-            .WithIncrement(null)
+            .WithIncrement(IncrementStrategy.Inherit)
+            .WithBranch("unknown", builder => builder.WithIncrement(IncrementStrategy.Inherit))
             .Build();
         var repositoryStoreMock = Substitute.For<IRepositoryStore>();
         repositoryStoreMock.GetSourceBranches(branchMock, configuration, Arg.Any<HashSet<IBranch>>()).Returns(Enumerable.Empty<IBranch>());
@@ -301,6 +279,7 @@ public void When_getting_configurations_of_an_unknown_branch_Given_fallback_conf
         var branchMock = GitToolsTestingExtensions.CreateMockBranch("unknown", GitToolsTestingExtensions.CreateMockCommit());
         var configuration = GitFlowConfigurationBuilder.New
             .WithIncrement(fallbackIncrement)
+            .WithBranch("unknown", builder => builder.WithIncrement(IncrementStrategy.Inherit))
             .Build();
         var repositoryStoreMock = Substitute.For<IRepositoryStore>();
         repositoryStoreMock.GetSourceBranches(branchMock, configuration, Arg.Any<HashSet<IBranch>>()).Returns(Enumerable.Empty<IBranch>());
@@ -318,13 +297,13 @@ public void When_getting_configurations_of_an_unknown_branch_Given_fallback_conf
 
     [Theory]
     public void When_getting_configurations_of_an_unknown_branch_Given_fallback_configuaration_with_increment_and_develop_branch_with_increment_Then_result_should_have_develop_increment(
-        IncrementStrategy fallbackIncrement, IncrementStrategy developBranchIncrement)
+        IncrementStrategy fallbackIncrement, IncrementStrategy developIncrement)
     {
         // Arrange
         var unknownBranchMock = GitToolsTestingExtensions.CreateMockBranch("unknown", GitToolsTestingExtensions.CreateMockCommit());
         var configuration = GitFlowConfigurationBuilder.New
             .WithIncrement(fallbackIncrement)
-            .WithBranch("develop", builder => builder.WithIncrement(developBranchIncrement))
+            .WithBranch("develop", builder => builder.WithIncrement(developIncrement))
             .Build();
         var repositoryStoreMock = Substitute.For<IRepositoryStore>();
         var developBranchMock = GitToolsTestingExtensions.CreateMockBranch("develop", GitToolsTestingExtensions.CreateMockCommit());
@@ -336,22 +315,24 @@ public void When_getting_configurations_of_an_unknown_branch_Given_fallback_conf
         var actual = unitUnderTest.GetConfigurations(unknownBranchMock, configuration).ToArray();
 
         // Assert
-        actual.ShouldHaveSingleItem();
-        actual[0].Branch.ShouldBe(developBranchMock);
-
-        if (developBranchIncrement == IncrementStrategy.Inherit)
+        if (fallbackIncrement == IncrementStrategy.Inherit && developIncrement == IncrementStrategy.Inherit)
         {
-            if (fallbackIncrement == IncrementStrategy.Inherit)
-            {
-                fallbackIncrement = IncrementStrategy.None;
-            }
-            actual[0].Value.Increment.ShouldBe(fallbackIncrement);
+            actual.ShouldBeEmpty();
         }
         else
         {
-            actual[0].Value.Increment.ShouldBe(developBranchIncrement);
-        }
+            actual.ShouldHaveSingleItem();
+            actual[0].Branch.ShouldBe(developBranchMock);
 
+            if (developIncrement == IncrementStrategy.Inherit)
+            {
+                actual[0].Value.Increment.ShouldBe(fallbackIncrement);
+            }
+            else
+            {
+                actual[0].Value.Increment.ShouldBe(developIncrement);
+            }
+        }
     }
 
     [Theory]
@@ -374,14 +355,16 @@ public void When_getting_configurations_of_an_unknown_branch_Given_fallback_conf
         var actual = unitUnderTest.GetConfigurations(unknownBranchMock, configuration).ToArray();
 
         // Assert
-        actual.ShouldHaveSingleItem();
-        actual[0].Branch.ShouldBe(developBranchMock);
-
         if (fallbackIncrement == IncrementStrategy.Inherit)
         {
-            fallbackIncrement = IncrementStrategy.None;
+            actual.ShouldBeEmpty();
+        }
+        else
+        {
+            actual.ShouldHaveSingleItem();
+            actual[0].Branch.ShouldBe(developBranchMock);
+            actual[0].Value.Increment.ShouldBe(fallbackIncrement);
         }
-        actual[0].Value.Increment.ShouldBe(fallbackIncrement);
     }
 
     [TestCase(IncrementStrategy.None)]
diff --git a/src/GitVersion.Core/Configuration/BranchConfiguration.cs b/src/GitVersion.Core/Configuration/BranchConfiguration.cs
@@ -42,7 +42,7 @@ public BranchConfiguration(BranchConfiguration branchConfiguration)
 
     [JsonPropertyName("increment")]
     [JsonPropertyDescription("The increment strategy for this branch. Can be 'Inherit', 'Patch', 'Minor', 'Major', 'None'.")]
-    public IncrementStrategy? Increment { get; set; }
+    public IncrementStrategy Increment { get; set; }
 
     [JsonPropertyName("prevent-increment-of-merged-branch-version")]
     [JsonPropertyDescription("Prevent increment of merged branch version.")]
@@ -105,7 +105,7 @@ public BranchConfiguration Inherit(BranchConfiguration? parentConfig)
 
         var result = new BranchConfiguration(this);
 
-        if (result.Increment is null || result.Increment == IncrementStrategy.Inherit)
+        if (result.Increment == IncrementStrategy.Inherit)
             result.Increment = parentConfig.Increment;
         result.VersioningMode ??= parentConfig.VersioningMode;
         result.Label ??= parentConfig.Label;
diff --git a/src/GitVersion.Core/Configuration/BranchConfigurationBuilder.cs b/src/GitVersion.Core/Configuration/BranchConfigurationBuilder.cs
@@ -9,7 +9,7 @@ public class BranchConfigurationBuilder
     private string name;
     private VersioningMode? versioningMode;
     private string? label;
-    private IncrementStrategy? increment;
+    private IncrementStrategy increment;
     private bool? preventIncrementOfMergedBranchVersion;
     private string? labelNumberPattern;
     private bool? trackMergeTarget;
@@ -45,7 +45,7 @@ public virtual BranchConfigurationBuilder WithLabel(string? value)
         return this;
     }
 
-    public virtual BranchConfigurationBuilder WithIncrement(IncrementStrategy? value)
+    public virtual BranchConfigurationBuilder WithIncrement(IncrementStrategy value)
     {
         this.increment = value;
         return this;
diff --git a/src/GitVersion.Core/Configuration/ConfigurationBuilderBase.cs b/src/GitVersion.Core/Configuration/ConfigurationBuilderBase.cs
@@ -27,7 +27,7 @@ internal abstract class ConfigurationBuilderBase<TConfigurationBuilder>
     private readonly Dictionary<string, BranchConfigurationBuilder> branchConfigurationBuilders = new();
     private VersioningMode? versioningMode;
     private string? label;
-    private IncrementStrategy? increment;
+    private IncrementStrategy increment = IncrementStrategy.Inherit;
     private bool? preventIncrementOfMergedBranchVersion;
     private string? labelNumberPattern;
     private bool? trackMergeTarget;
@@ -232,7 +232,7 @@ public virtual TConfigurationBuilder WithLabel(string? value)
         return (TConfigurationBuilder)this;
     }
 
-    public virtual TConfigurationBuilder WithIncrement(IncrementStrategy? value)
+    public virtual TConfigurationBuilder WithIncrement(IncrementStrategy value)
     {
         this.increment = value;
         return (TConfigurationBuilder)this;
diff --git a/src/GitVersion.Core/Configuration/ConfigurationExtensions.cs b/src/GitVersion.Core/Configuration/ConfigurationExtensions.cs
@@ -54,7 +54,6 @@ private static IEnumerable<BranchConfiguration> GetBranchConfigurations(GitVersi
     public static BranchConfiguration GetFallbackBranchConfiguration(this GitVersionConfiguration configuration)
     {
         BranchConfiguration result = new(configuration);
-        if (result.Increment == IncrementStrategy.Inherit) result.Increment = IncrementStrategy.None;
         return result;
     }
 
diff --git a/src/GitVersion.Core/Configuration/EffectiveConfiguration.cs b/src/GitVersion.Core/Configuration/EffectiveConfiguration.cs
@@ -22,9 +22,6 @@ public EffectiveConfiguration(GitVersionConfiguration configuration, BranchConfi
         if (!branchConfiguration.VersioningMode.HasValue)
             throw new Exception($"Configuration value for 'Versioning mode' for branch {name} has no value. (this should not happen, please report an issue)");
 
-        if (!branchConfiguration.Increment.HasValue)
-            throw new Exception($"Configuration value for 'Increment' for branch {name} has no value. (this should not happen, please report an issue)");
-
         if (!configuration.AssemblyVersioningScheme.HasValue)
             throw new Exception("Configuration value for 'AssemblyVersioningScheme' has no value. (this should not happen, please report an issue)");
 
@@ -46,7 +43,7 @@ public EffectiveConfiguration(GitVersionConfiguration configuration, BranchConfi
         LabelPrefix = configuration.LabelPrefix;
         Label = branchConfiguration.Label ?? string.Empty;
         NextVersion = configuration.NextVersion;
-        Increment = branchConfiguration.Increment.Value;
+        Increment = branchConfiguration.Increment;
         BranchPrefixToTrim = branchConfiguration.Regex;
         PreventIncrementOfMergedBranchVersion = branchConfiguration.PreventIncrementOfMergedBranchVersion ?? false;
         LabelNumberPattern = branchConfiguration.LabelNumberPattern;
diff --git a/src/GitVersion.Core/Configuration/GitVersionConfiguration.cs b/src/GitVersion.Core/Configuration/GitVersionConfiguration.cs
@@ -1,3 +1,7 @@
+using System.Globalization;
+using GitVersion.Attributes;
+using GitVersion.Extensions;
+
 namespace GitVersion.Configuration;
 
 public class GitVersionConfiguration : BranchConfiguration
diff --git a/src/GitVersion.Core/Core/GitVersionContextFactory.cs b/src/GitVersion.Core/Core/GitVersionContextFactory.cs
@@ -1,3 +1,8 @@
+using GitVersion.Common;
+using GitVersion.Configuration;
+using GitVersion.Extensions;
+using Microsoft.Extensions.Options;
+
 namespace GitVersion;
 
 public class GitVersionContextFactory : IGitVersionContextFactory
diff --git a/src/GitVersion.Core/Core/RepositoryStore.cs b/src/GitVersion.Core/Core/RepositoryStore.cs
@@ -140,20 +140,30 @@ public IEnumerable<IBranch> GetSourceBranches(IBranch branch, GitVersionConfigur
 
     public IEnumerable<IBranch> GetSourceBranches(IBranch branch, GitVersionConfiguration configuration, IEnumerable<IBranch> excludedBranches)
     {
+        var returnedBranches = new HashSet<IBranch>();
+
         var referenceLookup = this.repository.Refs.ToLookup(r => r.TargetIdentifier);
 
-        var returnedBranches = new HashSet<IBranch>();
-        if (referenceLookup.Any())
+        foreach (var branchGrouping in FindCommitBranchesWasBranchedFrom(branch, configuration, excludedBranches)
+            .GroupBy(element => element.Commit, element => element.Branch))
         {
-            foreach (var branchCommit in FindCommitBranchesWasBranchedFrom(branch, configuration, excludedBranches))
+            bool referenceMatchFound = false;
+            var referenceNames = referenceLookup[branchGrouping.Key.Sha].Select(element => element.Name).ToHashSet();
+
+            foreach (var item in branchGrouping)
+            {
+                if (referenceNames.Contains(item.Name))
+                {
+                    if (returnedBranches.Add(item)) yield return item;
+                    referenceMatchFound = true;
+                }
+            }
+
+            if (!referenceMatchFound)
             {
-                foreach (var _ in referenceLookup[branchCommit.Commit.Sha]
-                    .Where(r => r.Name.Friendly == branchCommit.Branch.Name.Friendly))
+                foreach (var item in branchGrouping)
                 {
-                    if (returnedBranches.Add(branchCommit.Branch))
-                    {
-                        yield return branchCommit.Branch;
-                    }
+                    if (returnedBranches.Add(item)) yield return item;
                 }
             }
         }
diff --git a/src/GitVersion.Core/PublicAPI.Unshipped.txt b/src/GitVersion.Core/PublicAPI.Unshipped.txt
@@ -94,7 +94,7 @@ GitVersion.Configuration.BranchConfiguration.BranchConfiguration() -> void
 GitVersion.Configuration.BranchConfiguration.BranchConfiguration(GitVersion.Configuration.BranchConfiguration! branchConfiguration) -> void
 GitVersion.Configuration.BranchConfiguration.CommitMessageIncrementing.get -> GitVersion.VersionCalculation.CommitMessageIncrementMode?
 GitVersion.Configuration.BranchConfiguration.CommitMessageIncrementing.set -> void
-GitVersion.Configuration.BranchConfiguration.Increment.get -> GitVersion.IncrementStrategy?
+GitVersion.Configuration.BranchConfiguration.Increment.get -> GitVersion.IncrementStrategy
 GitVersion.Configuration.BranchConfiguration.Increment.set -> void
 GitVersion.Configuration.BranchConfiguration.Inherit(GitVersion.Configuration.BranchConfiguration? parentConfig) -> GitVersion.Configuration.BranchConfiguration!
 GitVersion.Configuration.BranchConfiguration.IsMainline.get -> bool?
@@ -1188,7 +1188,7 @@ virtual GitVersion.Agents.BuildAgentBase.ShouldCleanUpRemotes() -> bool
 virtual GitVersion.Agents.BuildAgentBase.WriteIntegration(System.Action<string?>! writer, GitVersion.OutputVariables.VersionVariables! variables, bool updateBuildNumber = true) -> void
 virtual GitVersion.Configuration.BranchConfigurationBuilder.WithCommitMessageIncrementing(GitVersion.VersionCalculation.CommitMessageIncrementMode? value) -> GitVersion.Configuration.BranchConfigurationBuilder!
 virtual GitVersion.Configuration.BranchConfigurationBuilder.WithConfiguration(GitVersion.Configuration.BranchConfiguration! value) -> GitVersion.Configuration.BranchConfigurationBuilder!
-virtual GitVersion.Configuration.BranchConfigurationBuilder.WithIncrement(GitVersion.IncrementStrategy? value) -> GitVersion.Configuration.BranchConfigurationBuilder!
+virtual GitVersion.Configuration.BranchConfigurationBuilder.WithIncrement(GitVersion.IncrementStrategy value) -> GitVersion.Configuration.BranchConfigurationBuilder!
 virtual GitVersion.Configuration.BranchConfigurationBuilder.WithIsMainline(bool? value) -> GitVersion.Configuration.BranchConfigurationBuilder!
 virtual GitVersion.Configuration.BranchConfigurationBuilder.WithIsReleaseBranch(bool? value) -> GitVersion.Configuration.BranchConfigurationBuilder!
 virtual GitVersion.Configuration.BranchConfigurationBuilder.WithIsSourceBranchFor(System.Collections.Generic.IEnumerable<string!>? values) -> GitVersion.Configuration.BranchConfigurationBuilder!
diff --git a/src/GitVersion.Core/VersionCalculation/EffectiveBranchConfigurationFinder.cs b/src/GitVersion.Core/VersionCalculation/EffectiveBranchConfigurationFinder.cs
@@ -45,7 +45,7 @@ private IEnumerable<EffectiveBranchConfiguration> GetEffectiveConfigurationsRecu
             {
                 // Because the actual branch is marked with the inherit increment strategy we need to either skip the iteration or go further
                 // while inheriting from the fallback branch configuration. This behavior is configurable via the increment settings of the configuration.
-                var skipTraversingOfOrphanedBranches = configuration.Increment == null;
+                var skipTraversingOfOrphanedBranches = configuration.Increment == IncrementStrategy.Inherit;
                 this.log.Info(
                     $"An orphaned branch '{branch}' has been detected and will be skipped={skipTraversingOfOrphanedBranches}."
                 );
diff --git a/src/GitVersion.Core/VersionCalculation/MainlineVersionCalculator.cs b/src/GitVersion.Core/VersionCalculation/MainlineVersionCalculator.cs
@@ -300,21 +300,24 @@ private VersionField TryFindIncrementFromMergeMessage(ICommit? mergeCommit)
         {
             var mergeMessage = new MergeMessage(mergeCommit.Message, context.Configuration);
             var configuration = context.Configuration.GetBranchConfiguration(mergeMessage.MergedBranch);
-            if (configuration.Increment != null && configuration.Increment != IncrementStrategy.Inherit)
+            if (configuration.Increment != IncrementStrategy.Inherit)
             {
-                return configuration.Increment.Value.ToVersionField();
+                return configuration.Increment.ToVersionField();
             }
         }
 
-        // Fallback to configuration increment value
         return FindDefaultIncrementForBranch(context);
     }
 
     private static VersionField FindDefaultIncrementForBranch(GitVersionContext context)
         => FindDefaultIncrementForBranch(context, context.CurrentBranch);
 
     private static VersionField FindDefaultIncrementForBranch(GitVersionContext context, IBranch branch)
-        => context.Configuration.GetEffectiveConfiguration(branch).Increment.ToVersionField();
+    {
+        var increment = context.Configuration.GetEffectiveConfiguration(branch).Increment;
+        if (increment == IncrementStrategy.Inherit) increment = IncrementStrategy.Patch;
+        return increment.ToVersionField();
+    }
 
     private static ICommit GetMergedHead(ICommit mergeCommit)
     {

Original file line number	Diff line number	Diff line change
`@@ -443,11 +443,11 @@ public void VerifyIncrementConfigIsHonoured()`
`443`	`443`	`.WithIncrement(IncrementStrategy.Minor)`
`444`	`444`	`.WithBranch("main", builder => builder`
`445`	`445`	`.WithVersioningMode(VersioningMode.Mainline)`
`446`		`- .WithIncrement(null)`
	`446`	`+ .WithIncrement(IncrementStrategy.Inherit)`
`447`	`447`	`)`
`448`	`448`	`.WithBranch("feature", builder => builder`
`449`	`449`	`.WithVersioningMode(VersioningMode.Mainline)`
`450`		`- .WithIncrement(null)`
	`450`	`+ .WithIncrement(IncrementStrategy.Inherit)`
`451`	`451`	`)`
`452`	`452`	`.Build();`
`453`	`453`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public void TakesVersionFromNameOfRemoteReleaseBranchInOrigin()`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`[Test]`
`55`		`- public void DoesNotTakeVersionFromNameOfRemoteReleaseBranchInCustomRemote()`
	`55`	`+ public void TakesVersionFromNameOfRemoteReleaseBranchInCustom()`
`56`	`56`	`{`
`57`	`57`	`using var fixture = new RemoteRepositoryFixture();`
`58`	`58`	`fixture.LocalRepositoryFixture.Repository.Network.Remotes.Rename("origin", "upstream");`
`@@ -62,6 +62,6 @@ public void DoesNotTakeVersionFromNameOfRemoteReleaseBranchInCustomRemote()`
`62`	`62`
`63`	`63`	`fixture.LocalRepositoryFixture.Checkout("upstream/release/2.0.0");`
`64`	`64`
`65`		`- fixture.LocalRepositoryFixture.AssertFullSemver("0.0.0-beta.1+6"); // This test fails with 2.0.0-beta.1+1`
	`65`	`+ fixture.LocalRepositoryFixture.AssertFullSemver("2.0.0-beta.1+1");`
`66`	`66`	`}`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,6 @@ private static IEnumerable<BranchConfiguration> GetBranchConfigurations(GitVersi`
`54`	`54`	`public static BranchConfiguration GetFallbackBranchConfiguration(this GitVersionConfiguration configuration)`
`55`	`55`	`{`
`56`	`56`	`BranchConfiguration result = new(configuration);`
`57`		`- if (result.Increment == IncrementStrategy.Inherit) result.Increment = IncrementStrategy.None;`
`58`	`57`	`return result;`
`59`	`58`	`}`
`60`	`59`