public void Compare_And_CompareTo() { for (var i = 0; i < Versions.Length - 1; i++) { var a = Versions[i]; Assert.Equal(a, a); if (a != null) { Assert.Equal(a, SemVer.Parse(a.ToString())); } Assert.False(a < null); Assert.False(a > null); Assert.False(a <= null); Assert.False(a >= null); for (var j = i + 1; j < Versions.Length; j++) { var b = Versions[j]; Assert.NotEqual(a, b); Assert.True(SemVer.Compare(a, b) < 0, $"{ a } is not smaller than { b }"); if (a != null) { Assert.True(a.CompareTo(b) < 0); } } } Assert.Equal(Versions, Versions.OrderBy(x => x, Comparer <SemVer> .Default)); }
public IModel Load(PropertyBag modelData) { try { var model = new Model( modelData["name"] as string, SemVer.Parse(modelData["version"] as string), new ModelFactories(_valueTypeFactory, _validatorFactory, _entityFactory)) { PropertyBag = modelData }; model.EntitiesBySingleName = (modelData["entities"] as PropertyBag[]) .Safe() .ToImmutableDictionary(x => x["singlename"] as string, x => MapEntityDefinition(model, x), StringComparer.OrdinalIgnoreCase); model.EntitiesByPluralName = model.EntitiesBySingleName.Values.ToImmutableDictionary(x => x.PluralName); model.ModelLoaded(); return(model); } catch (Exception ex) when(!(ex is ModelLoadingException)) { throw new ModelLoadingException($"There has been an error while loading the model {modelData["name"]}", ex); } }
public void CanParseSemverString(string input, int major, int minor, int patch, string suffix) { var result = SemVer.Parse(input); Assert.Equal(result.Major, major); Assert.Equal(result.Minor, minor); Assert.Equal(result.Patch, patch); Assert.Equal(result.Suffix, suffix); }
private void Awake() { if (version != null && (version.autoBuild != SemVerAutoBuild.Type.Manual || version != new SemVer())) { return; } version = SemVer.Parse(Application.version); }
public void Parse_Invalid_With_Best_Guess(string str, string expectedGuess, int expectedIndex, string expectedError) { Assert.Throws <FormatException>(() => SemVer.Parse(str)); var success = SemVer.TryParse(str, out var version, out var error); Assert.False(success); Assert.Equal(expectedGuess, version.ToString()); Assert.Equal($"Error parsing version string '{ str }' at index { expectedIndex }: { expectedError }", error); }
public static void Main() { // This project exists to validate the c# that psake uses for version management SemVer semanticVersion = null; semanticVersion = SemVer.Parse("1.2.3"); semanticVersion = SemVer.Parse("1.2.3-pre"); semanticVersion = SemVer.Parse("1.2.3+meta"); semanticVersion = SemVer.Parse("1.2.3-pre+meta"); }
public void ParseVersionWorks() { SemVer.Parse("1.0.0").Should().Be(new SemVer(1, 0, 0)); SemVer.Parse("1.0.0-alpha").Should().Be(new SemVer(1, 0, 0, "alpha")); SemVer.Parse("1.0.0-alpha+info").Should().Be(new SemVer(1, 0, 0, "alpha", "info")); SemVer.Parse("1.0.0-alpha.1").Should().Be(new SemVer(1, 0, 0, "alpha.1", "info")); SemVer.Parse("1.0.0-alpha.2").Should().Be(new SemVer(1, 0, 0, "alpha.2", "info")); SemVer.Parse("1.0.0-alpha.1.2").Should().Be(new SemVer(1, 0, 0, "alpha.1.2", "info")); SemVer.Parse("1.2.3-alpha.4.5+6").Should().Be(new SemVer(1, 2, 3, "alpha.4.5", "6")); SemVer.Parse("1.2.3-Beta.4.5+6").Should().Be(new SemVer(1, 2, 3, "Beta.4.5", "6")); SemVer.Parse("1.2.3---alpha-abc.4.5+6").Should().Be(new SemVer(1, 2, 3, "--alpha-abc.4.5", "6")); }
public void NextVersion(string versionStr, VersionPart part, string expectedNextStr) { var version = SemVer.Parse(versionStr); var expectedNext = SemVer.Parse(expectedNextStr); var opts = new VersionCalculationOptions() { AutoIncrement = part, }; var actualNext = VersionCalculator.NextVersion(version, opts); actualNext.Should().Be(expectedNext); }
internal static bool ValidateVersion(string version) { SemVer currentVersion = SemVer.Parse(version); SemVerValidationResult valid = currentVersion.Validate(); if (valid.IsValid) { return(valid.Corrected.ToString() == version); } else { return(false); } }
public void CheckVersionBumps(string?versionStr, string?minVer, int height, string resultStr) { var options = new VersionCalculationOptions() { MinimumVersion = SemVer.Parse(minVer ?? "0.1.0"), }; var version = versionStr is null ? (SemVer?)null: SemVer.Parse(versionStr); var result = SemVer.Parse(resultStr); var gotVersion = VersionCalculator.FromTagInfomation(version, options, height); gotVersion.Should().Be(result); gotVersion.ToString().Should().Be(resultStr); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { if (property.type == "string") { Target = SemVer.Parse(property.stringValue); var corrected = DrawSemVer(position, property, label); property.stringValue = corrected.ToString(); return; } Debug.LogWarning($"{property.type} is not supported by {this}"); EditorGUI.BeginProperty(position, label, property); EditorGUI.PropertyField(position, property); EditorGUI.EndProperty(); }
private void AddRegistryPackage(UnityEditor.PackageManager.PackageInfo info) { try { SemVer latestVersion = SemVer.Parse(GetLatestVersion(info)); SemVer currentVersion = SemVer.Parse(info.version); if (currentVersion < latestVersion) { UpgradeablePackages.Add(info); } } catch (System.Exception) { Debug.LogError("Invalid version for package " + info.displayName + ". Current: " + info.version + ", Latest: " + GetLatestVersion(info)); } }
private static void UpdateManifest(UnityEditor.PackageManager.PackageInfo package) { JObject manifestJSON = JObject.Parse(AssetDatabaseUtilities.ReadTextFile(Paths.PackagesFolder, Paths.ProjectManifest)); var dependencies = (JObject)manifestJSON["dependencies"]; bool changed = false; string changes = ""; if (dependencies.ContainsKey(package.name)) { string version = dependencies[package.name].ToObject <string>(); if (SemVer.Parse(version).ToString() == version) { if (package.version != version) { changes += "\t" + package.name + "@" + version + "=>" + package.version; dependencies[package.name] = package.version; changed = true; } } } else { changes += "+\t" + package.name + "@" + package.version; JProperty property = new JProperty(package.name, package.version); dependencies.Add(property); changed = true; } if (changed) { AssetDatabaseUtilities.CreateTextFile(manifestJSON.ToString(), Paths.PackagesFolder, Paths.ProjectManifest); Debug.Log("Updated project dependencies" + Environment.NewLine + changes); } }
public PackageUpgradeState(UnityEditor.PackageManager.PackageInfo info) { this.info = info; previewAvailable = false; stableAvailable = false; verifiedAvailable = false; hasVerified = false; stableVersion = SemVer.Parse(info.version); previewVersion = SemVer.Parse(info.version); try { current = SemVer.Parse(info.version); } catch { Debug.LogError("Cannot parse version for package " + info.displayName + ": " + info.version); } if (info.source == PackageSource.Git) { previewAvailable = true; preview = info.packageId; stableAvailable = true; stable = info.packageId; } else if (info.source == PackageSource.Registry) { string[] compatible = info.versions.compatible; foreach (string ver in compatible) { try { SemVer version = SemVer.Parse(ver); if (string.IsNullOrWhiteSpace(version.preRelease)) { if (version > stableVersion) { stableVersion = version; stableAvailable = true; stable = info.name + "@" + ver; } } else { // This is a pre-release if (version > previewVersion) { previewVersion = version; previewAvailable = true; preview = info.name + "@" + ver; } } } catch { Debug.LogError("Invalid version for package " + info.displayName + ": " + ver); } } hasVerified = !String.IsNullOrWhiteSpace(info.versions.verified); if (hasVerified) { try { verifiedVersion = SemVer.Parse(info.versions.verified); if (verifiedVersion > current) { verifiedAvailable = verifiedVersion > current; verified = info.name + "@" + info.versions.verified; } } catch { Debug.LogError("Cannot parse version for package " + info.displayName + ": " + info.versions.verified); } } } }
public void Parse(string value, SemVer expected) { SemVer.Parse(value).ShouldBeEquivalentTo(expected); }
public void ToStringOutputsTheSemverString() { var semver = SemVer.Parse("1.2.3-pre1"); Assert.Equal("1.2.3-pre1", semver.ToString()); }
public void ThrowsWhenNotMatch() { Assert.Throws <InvalidOperationException>(() => SemVer.Parse("this is not a semver string")); }
public void ValidVersionsParse(string version) { _ = SemVer.Parse(version); }
public void InvalidVersionsFailParse(string version) { SemVer.TryParse(version, out _).Should().BeFalse(); Assert.Throws <FormatException>(() => SemVer.Parse(version)); }
public void Parse_ToString(string str) { Assert.Equal(str, SemVer.Parse(str).ToString()); }
public void Parse_Methods_ThrowOnNull() { Assert.Throws <ArgumentNullException>(() => SemVer.Parse(null)); Assert.Throws <ArgumentNullException>(() => SemVer.TryParse(null, out var v)); Assert.Throws <ArgumentNullException>(() => SemVer.TryParse(null, out var v, out var e)); }