add full internal support for non-standard four-part versions

1 files changed, 162 insertions, 46 deletions

diff --git a/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs b/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
index 48afcaa2..ac4ef39b 100644
--- a/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
+++ b/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
@@ -17,7 +17,8 @@ namespace SMAPI.Tests.Utilities
         /****
         ** Constructor
         ****/
-        [Test(Description = "Assert that the constructor sets the expected values for all valid versions when constructed from a string.")]
+        /// <summary>Assert the parsed version when constructed from a standard string.</summary>
+        /// <param name="input">The version string to parse.</param>
         [TestCase("1.0", ExpectedResult = "1.0.0")]
         [TestCase("1.0.0", ExpectedResult = "1.0.0")]
         [TestCase("3000.4000.5000", ExpectedResult = "3000.4000.5000")]
@@ -29,10 +30,76 @@ namespace SMAPI.Tests.Utilities
         [TestCase("1.2+3.4.5-build.004", ExpectedResult = "1.2.0+3.4.5-build.004")]
         public string Constructor_FromString(string input)
         {
-            return new SemanticVersion(input).ToString();
+            // act
+            ISemanticVersion version = new SemanticVersion(input);
+
+            // assert
+            return version.ToString();
         }
 
-        [Test(Description = "Assert that the constructor sets the expected values for all valid versions when constructed from the individual numbers.")]
+
+        /// <summary>Assert that the constructor rejects invalid values when constructed from a string.</summary>
+        /// <param name="input">The version string to parse.</param>
+        [Test(Description = "Assert that the constructor throws the expected exception for invalid versions.")]
+        [TestCase(null)]
+        [TestCase("")]
+        [TestCase("   ")]
+        [TestCase("1")]
+        [TestCase("01.0")]
+        [TestCase("1.05")]
+        [TestCase("1.5.06")] // leading zeros specifically prohibited by spec
+        [TestCase("1.2.3.4")]
+        [TestCase("1.apple")]
+        [TestCase("1.2.apple")]
+        [TestCase("1.2.3.apple")]
+        [TestCase("1..2..3")]
+        [TestCase("1.2.3-")]
+        [TestCase("1.2.3--some-tag")]
+        [TestCase("1.2.3-some-tag...")]
+        [TestCase("1.2.3-some-tag...4")]
+        [TestCase("1.2.3-some-tag.4+build...4")]
+        [TestCase("apple")]
+        [TestCase("-apple")]
+        [TestCase("-5")]
+        public void Constructor_FromString_WithInvalidValues(string input)
+        {
+            if (input == null)
+                this.AssertAndLogException<ArgumentNullException>(() => new SemanticVersion(input));
+            else
+                this.AssertAndLogException<FormatException>(() => new SemanticVersion(input));
+        }
+
+        /// <summary>Assert the parsed version when constructed from a non-standard string.</summary>
+        /// <param name="input">The version string to parse.</param>
+        [TestCase("1.2.3", ExpectedResult = "1.2.3")]
+        [TestCase("1.0.0.0", ExpectedResult = "1.0.0")]
+        [TestCase("1.0.0.5", ExpectedResult = "1.0.0.5")]
+        [TestCase("1.2.3.4-some-tag.4      ", ExpectedResult = "1.2.3.4-some-tag.4")]
+        public string Constructor_FromString_NonStandard(string input)
+        {
+            // act
+            ISemanticVersion version = new SemanticVersion(input, allowNonStandard: true);
+
+            // assert
+            return version.ToString();
+        }
+
+        /// <summary>Assert that the constructor rejects a non-standard string when the non-standard flag isn't set.</summary>
+        /// <param name="input">The version string to parse.</param>
+        [TestCase("1.0.0.0")]
+        [TestCase("1.0.0.5")]
+        [TestCase("1.2.3.4-some-tag.4      ")]
+        public void Constructor_FromString_Standard_DisallowsNonStandardVersion(string input)
+        {
+            Assert.Throws<FormatException>(() => new SemanticVersion(input));
+        }
+
+        /// <summary>Assert the parsed version when constructed from standard parts.</summary>
+        /// <param name="major">The major number.</param>
+        /// <param name="minor">The minor number.</param>
+        /// <param name="patch">The patch number.</param>
+        /// <param name="prerelease">The prerelease tag.</param>
+        /// <param name="build">The build metadata.</param>
         [TestCase(1, 0, 0, null, null, ExpectedResult = "1.0.0")]
         [TestCase(3000, 4000, 5000, null, null, ExpectedResult = "3000.4000.5000")]
         [TestCase(1, 2, 3, "", null, ExpectedResult = "1.2.3")]
@@ -49,15 +116,43 @@ namespace SMAPI.Tests.Utilities
             ISemanticVersion version = new SemanticVersion(major, minor, patch, prerelease, build);
 
             // assert
-            Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value.");
-            Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value.");
-            Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value.");
-            Assert.AreEqual(string.IsNullOrWhiteSpace(prerelease) ? null : prerelease.Trim(), version.PrereleaseTag, "The prerelease tag doesn't match the given value.");
-            Assert.AreEqual(string.IsNullOrWhiteSpace(build) ? null : build.Trim(), version.BuildMetadata, "The build metadata doesn't match the given value.");
+            this.AssertParts(version, major, minor, patch, prerelease, build, nonStandard: false);
             return version.ToString();
         }
 
-        [Test(Description = "Assert that the constructor throws the expected exception for invalid versions when constructed from the individual numbers.")]
+        /// <summary>Assert the parsed version when constructed from parts including non-standard fields.</summary>
+        /// <param name="major">The major number.</param>
+        /// <param name="minor">The minor number.</param>
+        /// <param name="patch">The patch number.</param>
+        /// <param name="platformRelease">The non-standard platform release number.</param>
+        /// <param name="prerelease">The prerelease tag.</param>
+        /// <param name="build">The build metadata.</param>
+        [TestCase(1, 0, 0, 0, null, null, ExpectedResult = "1.0.0")]
+        [TestCase(3000, 4000, 5000, 6000, null, null, ExpectedResult = "3000.4000.5000.6000")]
+        [TestCase(1, 2, 3, 4, "", null, ExpectedResult = "1.2.3.4")]
+        [TestCase(1, 2, 3, 4, "    ", null, ExpectedResult = "1.2.3.4")]
+        [TestCase(1, 2, 3, 4, "0", null, ExpectedResult = "1.2.3.4-0")]
+        [TestCase(1, 2, 3, 4, "some-tag.4", null, ExpectedResult = "1.2.3.4-some-tag.4")]
+        [TestCase(1, 2, 3, 4, "sOMe-TaG.4", null, ExpectedResult = "1.2.3.4-sOMe-TaG.4")]
+        [TestCase(1, 2, 3, 4, "some-tag.4   ", null, ExpectedResult = "1.2.3.4-some-tag.4")]
+        [TestCase(1, 2, 3, 4, "some-tag.4   ", "build.004", ExpectedResult = "1.2.3.4-some-tag.4+build.004")]
+        [TestCase(1, 2, 0, 4, null, "3.4.5-build.004", ExpectedResult = "1.2.0.4+3.4.5-build.004")]
+        public string Constructor_FromParts_NonStandard(int major, int minor, int patch, int platformRelease, string prerelease, string build)
+        {
+            // act
+            ISemanticVersion version = new SemanticVersion(major, minor, patch, platformRelease, prerelease, build);
+
+            // assert
+            this.AssertParts(version, major, minor, patch, prerelease, build, nonStandard: platformRelease != 0);
+            return version.ToString();
+        }
+
+        /// <summary>Assert that the constructor rejects invalid values when constructed from the individual numbers.</summary>
+        /// <param name="major">The major number.</param>
+        /// <param name="minor">The minor number.</param>
+        /// <param name="patch">The patch number.</param>
+        /// <param name="prerelease">The prerelease tag.</param>
+        /// <param name="build">The build metadata.</param>
         [TestCase(0, 0, 0, null, null)]
         [TestCase(-1, 0, 0, null, null)]
         [TestCase(0, -1, 0, null, null)]
@@ -71,6 +166,10 @@ namespace SMAPI.Tests.Utilities
             this.AssertAndLogException<FormatException>(() => new SemanticVersion(major, minor, patch, prerelease, build));
         }
 
+        /// <summary>Assert the parsed version when constructed from an assembly version.</summary>
+        /// <param name="major">The major number.</param>
+        /// <param name="minor">The minor number.</param>
+        /// <param name="patch">The patch number.</param>
         [Test(Description = "Assert that the constructor sets the expected values for all valid versions when constructed from an assembly version.")]
         [TestCase(1, 0, 0, ExpectedResult = "1.0.0")]
         [TestCase(1, 2, 3, ExpectedResult = "1.2.3")]
@@ -81,45 +180,16 @@ namespace SMAPI.Tests.Utilities
             ISemanticVersion version = new SemanticVersion(new Version(major, minor, patch));
 
             // assert
-            Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value.");
-            Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value.");
-            Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value.");
+            this.AssertParts(version, major, minor, patch, null, null, nonStandard: false);
             return version.ToString();
         }
 
-        [Test(Description = "Assert that the constructor throws the expected exception for invalid versions.")]
-        [TestCase(null)]
-        [TestCase("")]
-        [TestCase("   ")]
-        [TestCase("1")]
-        [TestCase("01.0")]
-        [TestCase("1.05")]
-        [TestCase("1.5.06")] // leading zeros specifically prohibited by spec
-        [TestCase("1.2.3.4")]
-        [TestCase("1.apple")]
-        [TestCase("1.2.apple")]
-        [TestCase("1.2.3.apple")]
-        [TestCase("1..2..3")]
-        [TestCase("1.2.3-")]
-        [TestCase("1.2.3--some-tag")]
-        [TestCase("1.2.3-some-tag...")]
-        [TestCase("1.2.3-some-tag...4")]
-        [TestCase("1.2.3-some-tag.4+build...4")]
-        [TestCase("apple")]
-        [TestCase("-apple")]
-        [TestCase("-5")]
-        public void Constructor_FromString_WithInvalidValues(string input)
-        {
-            if (input == null)
-                this.AssertAndLogException<ArgumentNullException>(() => new SemanticVersion(input));
-            else
-                this.AssertAndLogException<FormatException>(() => new SemanticVersion(input));
-        }
-
         /****
         ** CompareTo
         ****/
-        [Test(Description = "Assert that version.CompareTo returns the expected value.")]
+        /// <summary>Assert that <see cref="ISemanticVersion.CompareTo"/> returns the expected value.</summary>
+        /// <param name="versionStrA">The left version.</param>
+        /// <param name="versionStrB">The right version.</param>
         // equal
         [TestCase("0.5.7", "0.5.7", ExpectedResult = 0)]
         [TestCase("1.0", "1.0", ExpectedResult = 0)]
@@ -149,15 +219,20 @@ namespace SMAPI.Tests.Utilities
         [TestCase("1.0-beta-10", "1.0-beta-2", ExpectedResult = 1)]
         public int CompareTo(string versionStrA, string versionStrB)
         {
+            // arrange
             ISemanticVersion versionA = new SemanticVersion(versionStrA);
             ISemanticVersion versionB = new SemanticVersion(versionStrB);
+
+            // assert
             return versionA.CompareTo(versionB);
         }
 
         /****
         ** IsOlderThan
         ****/
-        [Test(Description = "Assert that version.IsOlderThan returns the expected value.")]
+        /// <summary>Assert that <see cref="ISemanticVersion.IsOlderThan(string)"/> and <see cref="ISemanticVersion.IsOlderThan(ISemanticVersion)"/> return the expected value.</summary>
+        /// <param name="versionStrA">The left version.</param>
+        /// <param name="versionStrB">The right version.</param>
         // keep test cases in sync with CompareTo for simplicity.
         // equal
         [TestCase("0.5.7", "0.5.7", ExpectedResult = false)]
@@ -187,15 +262,21 @@ namespace SMAPI.Tests.Utilities
         [TestCase("1.0-beta-10", "1.0-beta-2", ExpectedResult = false)]
         public bool IsOlderThan(string versionStrA, string versionStrB)
         {
+            // arrange
             ISemanticVersion versionA = new SemanticVersion(versionStrA);
             ISemanticVersion versionB = new SemanticVersion(versionStrB);
+
+            // assert
+            Assert.AreEqual(versionA.IsOlderThan(versionB), versionA.IsOlderThan(versionB.ToString()), "The two signatures returned different results.");
             return versionA.IsOlderThan(versionB);
         }
 
         /****
         ** IsNewerThan
         ****/
-        [Test(Description = "Assert that version.IsNewerThan returns the expected value.")]
+        /// <summary>Assert that <see cref="ISemanticVersion.IsNewerThan(string)"/> and <see cref="ISemanticVersion.IsNewerThan(ISemanticVersion)"/> return the expected value.</summary>
+        /// <param name="versionStrA">The left version.</param>
+        /// <param name="versionStrB">The right version.</param>
         // keep test cases in sync with CompareTo for simplicity.
         // equal
         [TestCase("0.5.7", "0.5.7", ExpectedResult = false)]
@@ -225,14 +306,22 @@ namespace SMAPI.Tests.Utilities
         [TestCase("1.0-beta-10", "1.0-beta-2", ExpectedResult = true)]
         public bool IsNewerThan(string versionStrA, string versionStrB)
         {
+            // arrange
             ISemanticVersion versionA = new SemanticVersion(versionStrA);
             ISemanticVersion versionB = new SemanticVersion(versionStrB);
+
+            // assert
+            Assert.AreEqual(versionA.IsNewerThan(versionB), versionA.IsNewerThan(versionB.ToString()), "The two signatures returned different results.");
             return versionA.IsNewerThan(versionB);
         }
 
         /****
         ** IsBetween
         ****/
+        /// <summary>Assert that <see cref="ISemanticVersion.IsBetween(string, string)"/> and <see cref="ISemanticVersion.IsBetween(ISemanticVersion, ISemanticVersion)"/> return the expected value.</summary>
+        /// <param name="versionStr">The main version.</param>
+        /// <param name="lowerStr">The lower version number.</param>
+        /// <param name="upperStr">The upper version number.</param>
         [Test(Description = "Assert that version.IsNewerThan returns the expected value.")]
         // is between
         [TestCase("0.5.7-beta.3", "0.5.7-beta.3", "0.5.7-beta.3", ExpectedResult = true)]
@@ -250,17 +339,24 @@ namespace SMAPI.Tests.Utilities
         [TestCase("1.0-beta-2", "1.0-beta-10", "1.0-beta-3", ExpectedResult = false)]
         public bool IsBetween(string versionStr, string lowerStr, string upperStr)
         {
+            // arrange
             ISemanticVersion lower = new SemanticVersion(lowerStr);
             ISemanticVersion upper = new SemanticVersion(upperStr);
             ISemanticVersion version = new SemanticVersion(versionStr);
+
+            // assert
+            Assert.AreEqual(version.IsBetween(lower, upper), version.IsBetween(lower.ToString(), upper.ToString()), "The two signatures returned different results.");
             return version.IsBetween(lower, upper);
         }
 
         /****
         ** Serializable
         ****/
-        [Test(Description = "Assert that SemanticVersion can be round-tripped through JSON with no special configuration.")]
+        /// <summary>Assert that the version can be round-tripped through JSON with no special configuration.</summary>
+        /// <param name="versionStr">The semantic version.</param>
         [TestCase("1.0.0")]
+        [TestCase("1.0.0-beta.400")]
+        [TestCase("1.0.0-beta.400+build")]
         public void Serializable(string versionStr)
         {
             // act
@@ -272,10 +368,12 @@ namespace SMAPI.Tests.Utilities
             Assert.AreEqual(versionStr, after.ToString(), "The semantic version after deserialization doesn't match the input version.");
         }
 
+
         /****
         ** GameVersion
         ****/
-        [Test(Description = "Assert that the GameVersion subclass correctly parses legacy game versions.")]
+        /// <summary>Assert that the GameVersion subclass correctly parses non-standard game versions.</summary>
+        /// <param name="versionStr">The raw version.</param>
         [TestCase("1.0")]
         [TestCase("1.01")]
         [TestCase("1.02")]
@@ -307,6 +405,24 @@ namespace SMAPI.Tests.Utilities
         /*********
         ** Private methods
         *********/
+        /// <summary>Assert that the version matches the expected parts.</summary>
+        /// <param name="version">The version number.</param>
+        /// <param name="major">The major number.</param>
+        /// <param name="minor">The minor number.</param>
+        /// <param name="patch">The patch number.</param>
+        /// <param name="prerelease">The prerelease tag.</param>
+        /// <param name="build">The build metadata.</param>
+        /// <param name="nonStandard">Whether the version should be marked as non-standard.</param>
+        private void AssertParts(ISemanticVersion version, int major, int minor, int patch, string prerelease, string build, bool nonStandard)
+        {
+            Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match.");
+            Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match.");
+            Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match.");
+            Assert.AreEqual(string.IsNullOrWhiteSpace(prerelease) ? null : prerelease.Trim(), version.PrereleaseTag, "The prerelease tag doesn't match.");
+            Assert.AreEqual(string.IsNullOrWhiteSpace(build) ? null : build.Trim(), version.BuildMetadata, "The build metadata doesn't match.");
+            Assert.AreEqual(nonStandard, version.IsNonStandard(), $"The version is incorrectly marked {(nonStandard ? "standard" : "non-standard")}.");
+        }
+
         /// <summary>Assert that the expected exception type is thrown, and log the action output and thrown exception.</summary>
         /// <typeparam name="T">The expected exception type.</typeparam>
         /// <param name="action">The action which may throw the exception.</param>