public VersionedApplication AddVersionedApplication(string applicationIdentifier, string applicationDescription,
SemVersion startingVersion)
{
var versionedApplicationState = new VersionedApplicationState("", "");
versionedApplicationState.BuildHistory.Add(new VersionControlIdEntry("", startingVersion));
return new VersionedApplication(versionedApplicationState);
}
private static void HandleMigrations()
{
const string productName = "Redirects";
var currentVersion = new SemVersion(0, 0, 0);
// get all migrations for "Statistics" already executed
var migrations = ApplicationContext.Current.Services.MigrationEntryService.GetAll(productName);
// get the latest migration for "Statistics" executed
var latestMigration = migrations.OrderByDescending(x => x.Version).FirstOrDefault();
if (latestMigration != null)
currentVersion = latestMigration.Version;
var targetVersion = new SemVersion(1, 0, 1);
if (targetVersion == currentVersion)
return;
var migrationsRunner = new MigrationRunner(
ApplicationContext.Current.Services.MigrationEntryService,
ApplicationContext.Current.ProfilingLogger.Logger,
currentVersion,
targetVersion,
productName);
try
{
migrationsRunner.Execute(UmbracoContext.Current.Application.DatabaseContext.Database);
}
catch (HttpException e){}
catch (Exception e)
{
LogHelper.Error<MigrationRunner>("Error running Redirects migration", e);
}
}
public DataFileTypeInfoProperty(SemVersion v, string n, string t, Func<BaseDataFile, BaseDataFile> g, Action<BaseDataFile, BaseDataFile> s)
{
MinimalVersion = v;
PropertyName = n;
TypeName = t;
Getter = g;
Setter = s;
}
/// <summary>Initialises a new instance of the <see cref="ChangeVersionViewModel"/> class.</summary>
/// <param name="version">The version that is going to be changed.</param>
public ChangeVersionViewModel(SemVersion version)
{
this.Major = version.Major;
this.Minor = version.Minor;
this.Patch = version.Patch;
this.Prerelease = version.Prerelease;
this.Build = version.Build;
}
void Init(string owner, string name, SemVersion version)
{
Github = new GitHubClient(new ProductHeaderValue(name + @"-UpdateCheck"));
_releaseClient = Github.Release;
RepositoryOwner = owner;
RepostoryName = name;
CurrentVersion = version;
}
public void CreateVersionTest()
{
var v = new SemVersion(1, 2, 3, "a", "b");
Assert.AreEqual(1, v.Major);
Assert.AreEqual(2, v.Minor);
Assert.AreEqual(3, v.Patch);
Assert.AreEqual("a", v.Prerelease);
Assert.AreEqual("b", v.Build);
}
public void CreateVersionTestWithNulls()
{
var v = new SemVersion(1, 2, 3, null, null);
Assert.AreEqual(1, v.Major);
Assert.AreEqual(2, v.Minor);
Assert.AreEqual(3, v.Patch);
Assert.AreEqual("", v.Prerelease);
Assert.AreEqual("", v.Build);
}
public void CreateVersionTestWithSystemVersion2()
{
var v = new SemVersion(null);
Assert.AreEqual(0, v.Major);
Assert.AreEqual(0, v.Minor);
Assert.AreEqual(0, v.Patch);
Assert.AreEqual("", v.Build);
Assert.AreEqual("", v.Prerelease);
}
public void CreateVersionTestWithSystemVersion3()
{
var nonSemanticVersion = new Version(1, 2, 0, 3);
var v = new SemVersion(nonSemanticVersion);
Assert.AreEqual(1, v.Major);
Assert.AreEqual(2, v.Minor);
Assert.AreEqual(3, v.Patch);
Assert.AreEqual("", v.Build);
Assert.AreEqual("", v.Prerelease);
}
public override void Deserialize(IDataReader reader, SemVersion archiveVersion)
{
try
{
Value = Guid.ParseExact(reader.ReadFixedLengthNonEscapedASCII(36), "D");
}
catch (Exception e)
{
throw new SAMPersistanceException(e);
}
}
public async Task<UpdateType> CheckUpdate(UpdateType locked = UpdateType.None)
{
var releases = await _releaseClient.GetAll(RepositoryOwner, RepostoryName);
SemVersion lockedVersion;
switch (locked)
{
case UpdateType.Major:
lockedVersion = new SemVersion(CurrentVersion.Major + 1);
LatestRelease = releases.FirstOrDefault(
release => !release.Prerelease &&
Helper.StripInitialV(release.TagName) > CurrentVersion &&
Helper.StripInitialV(release.TagName) < lockedVersion
);
break;
case UpdateType.Minor:
lockedVersion = new SemVersion(CurrentVersion.Major, CurrentVersion.Minor + 1);
LatestRelease = releases.FirstOrDefault(
release => !release.Prerelease &&
Helper.StripInitialV(release.TagName) > CurrentVersion &&
Helper.StripInitialV(release.TagName) < lockedVersion
);
break;
default:
LatestRelease = releases.FirstOrDefault(
release => !release.Prerelease &&
Helper.StripInitialV(release.TagName) > CurrentVersion
);
break;
}
if (LatestRelease == null) return UpdateType.None;
var tagName = LatestRelease.TagName;
var latestVersion = Helper.StripInitialV(tagName);
if (latestVersion.Major != CurrentVersion.Major)
return UpdateType.Major;
if (latestVersion.Minor != CurrentVersion.Minor)
return UpdateType.Minor;
if (latestVersion.Patch != CurrentVersion.Patch)
return UpdateType.Patch;
return UpdateType.None;
}
public void Delete(SemVersion semver)
{
// Create a retrieve operation that expects a customer entity.
var retrieveOperation = TableOperation.Retrieve<ReleaseEntity>(semver.ToString(), semver.ToString());
// Execute the operation.
var retrievedResult = _table.Execute(retrieveOperation);
// Assign the result to a CustomerEntity.
var deleteEntity = (ReleaseEntity) retrievedResult.Result;
// Create the Delete TableOperation.
if (deleteEntity != null)
{
var deleteOperation = TableOperation.Delete(deleteEntity);
// Execute the operation.
_table.Execute(deleteOperation);
}
}
public void GreaterOrEqualOperatorTest1()
{
var v1 = new SemVersion(1);
var v2 = new SemVersion(1);
var r = v1 >= v2;
Assert.IsTrue(r);
}
public VersionData(string version, string minVersion)
{
Version = SemVersion.Parse(version);
MinVersion = SemVersion.Parse(minVersion);
}
internal static SemVersion GetAppVersion()
{
var attribute = (AssemblyInformationalVersionAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), true).Single();
return(SemVersion.Parse(attribute.InformationalVersion));
}
public void WriteVersion(SemVersion v)
{
WriteSimpleInteger(v.Mayor, 5);
WriteSimpleInteger(v.Minor, 5);
WriteSimpleInteger(v.Patch, 5);
}
public VerifyLoaderVersionAttribute(SemVersion semver, bool is_minimum)
{
SemVer = semver;
IsMinimum = is_minimum;
}
public void StaticEqualsTest3()
{
var v1 = new SemVersion(1);
var r = SemVersion.Equals(v1, null);
Assert.IsFalse(r);
}
public void TestSerialization()
{
var semVer = new SemVersion(1, 2, 3, "alpha", "dev");
SemVersion semVerSerializedDeserialized;
using (var ms = new MemoryStream())
{
var bf = new BinaryFormatter();
bf.Serialize(ms, semVer);
ms.Position = 0;
semVerSerializedDeserialized = (SemVersion) bf.Deserialize(ms);
}
Assert.AreEqual(semVer, semVerSerializedDeserialized);
}
public void TryParseTest2()
{
SemVersion v;
Assert.False(SemVersion.TryParse("ui-2.1-alpha", out v));
}
public void TryParseTest3()
{
SemVersion v;
Assert.False(SemVersion.TryParse("", out v));
}
public void ParseTestStrict4()
{
Assert.Throws <InvalidOperationException>(() => SemVersion.Parse("1.3-alpha", true));
}
public void TryParseTest1()
{
SemVersion v;
Assert.True(SemVersion.TryParse("1.2.45-alpha-beta+nightly.23.43-bla", out v));
}
public void ParseTest7()
{
Assert.Throws <ArgumentException>(() => SemVersion.Parse("ui-2.1-alpha"));
}
public void CompareTestWithStrings2()
{
var v = new SemVersion(1, 0, 0);
Assert.True(v < "1.1");
}
private static bool DifferByBuildOnly(SemVersion v1, SemVersion v2)
{
return(v1.Change(build: "").Equals(v2.Change(build: "")));
}
public void StaticCompareTest1()
{
var v1 = new SemVersion(1);
var v2 = new SemVersion(2);
var r = SemVersion.Compare(v1, v2);
Assert.AreEqual(-1, r);
}
public void CompareTestWithStrings3()
{
var v = new SemVersion(1, 2);
Assert.True(v > "1.0.0");
}
public void StaticCompareTest3()
{
var v1 = new SemVersion(1);
var r = SemVersion.Compare(null, v1);
Assert.AreEqual(-1, r);
}
public void TryParseTest4()
{
SemVersion v;
Assert.False(SemVersion.TryParse(null, out v));
}
public void TestChangeMinor()
{
var v1 = new SemVersion(1, 2, 3, "alpha", "dev");
var v2 = v1.Change(minor: 5);
Assert.AreEqual(1, v2.Major);
Assert.AreEqual(5, v2.Minor);
Assert.AreEqual(3, v2.Patch);
Assert.AreEqual("alpha", v2.Prerelease);
Assert.AreEqual("dev", v2.Build);
}
public void TryParseTest5()
{
SemVersion v;
Assert.True(SemVersion.TryParse("1.2", out v, false));
}
public void ToStringTest()
{
var version = new SemVersion(1, 2, 0, "beta", "dev-mha.120");
Assert.AreEqual("1.2.0-beta+dev-mha.120", version.ToString());
}
public void TryParseTest6()
{
SemVersion v;
Assert.False(SemVersion.TryParse("1.2", out v, true));
}
public bool TryGetMinSemVersion(out SemVersion semVersion)
{
return(TryParseSemVersion(this.Min, out semVersion));
}
public void ToStringTest()
{
var version = new SemVersion(1, 2, 0, "beta", "dev-mha.120");
Assert.Equal("1.2.0-beta+dev-mha.120", version.ToString());
}
public VerifyLoaderVersionAttribute(string version, bool is_minimum) : this(SemVersion.Parse(version), is_minimum) { }
public void TestStringConversion()
{
SemVersion v = "1.0.0";
Assert.Equal(1, v.Major);
}
public MigrationRunner(IMigrationEntryService migrationEntryService, ILogger logger, SemVersion currentVersion, SemVersion targetVersion, string productName, params IMigration[] migrations)
{
if (migrationEntryService == null)
{
throw new ArgumentNullException("migrationEntryService");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (currentVersion == null)
{
throw new ArgumentNullException("currentVersion");
}
if (targetVersion == null)
{
throw new ArgumentNullException("targetVersion");
}
Mandate.ParameterNotNullOrEmpty(productName, "productName");
_migrationEntryService = migrationEntryService;
_logger = logger;
_currentVersion = currentVersion;
_targetVersion = targetVersion;
_productName = productName;
//ensure this is null if there aren't any
_migrations = migrations.Length == 0 ? null : migrations;
}
public void StaticEqualsTest2()
{
var r = SemVersion.Equals(null, null);
Assert.True(r);
}
public void GreaterOperatorTest()
{
var v1 = new SemVersion(1);
var v2 = new SemVersion(2);
var r = v1 > v2;
Assert.IsFalse(r);
}
public void StaticCompareTest4()
{
var r = SemVersion.Compare(null, null);
Assert.Equal(0, r);
}
public void LessOrEqualOperatorTest2()
{
var v1 = new SemVersion(1);
var v2 = new SemVersion(2);
var r = v1 <= v2;
Assert.IsTrue(r);
}
public override void Serialize(IDataWriter writer, SemVersion currentVersion)
{
writer.WriteDouble(Value);
}
public void StaticCompareTest2()
{
var v1 = new SemVersion(1);
var r = SemVersion.Compare(v1, null);
Assert.AreEqual(1, r);
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var(status, failureMessage) = await _apiService.GetStatusAsync();
if (status == null)
{
await WriteUtils.PrintErrorAsync(failureMessage);
return;
}
var pluginId = string.Empty;
if (context.Extras != null && context.Extras.Length > 0)
{
pluginId = context.Extras[0];
}
var pluginPath = string.IsNullOrEmpty(pluginId)
? _settingsManager.ContentRootPath
: PathUtils.Combine(_pathManager.GetPluginPath(pluginId));
var(plugin, errorMessage) = await PluginUtils.ValidateManifestAsync(pluginPath);
if (plugin == null)
{
await WriteUtils.PrintErrorAsync(errorMessage);
return;
}
if (!string.IsNullOrEmpty(_version))
{
SemVersion.TryParse(plugin.Version, out var pluginVersion);
string versionChanged;
if (_version == "major")
{
versionChanged = pluginVersion.Change(pluginVersion.Major + 1).ToString();
}
else if (_version == "minor")
{
versionChanged = pluginVersion.Change(pluginVersion.Major, pluginVersion.Minor + 1).ToString();
}
else if (_version == "patch")
{
versionChanged = pluginVersion.Change(pluginVersion.Major, pluginVersion.Minor, pluginVersion.Patch + 1).ToString();
}
else if (PluginUtils.IsSemVersion(_version))
{
versionChanged = _version;
}
else
{
await WriteUtils.PrintErrorAsync($"Invalid plugin version '{_version}'");
return;
}
if (versionChanged != plugin.Version)
{
await PluginUtils.UpdateVersionAsync(pluginPath, versionChanged);
(plugin, errorMessage) = await PluginUtils.ValidateManifestAsync(pluginPath);
if (plugin == null)
{
await WriteUtils.PrintErrorAsync(errorMessage);
return;
}
}
}
var packageId = PluginUtils.GetPackageId(plugin.Publisher, plugin.Name, plugin.Version);
var zipPath = PluginPackageJob.Package(_pathManager, plugin);
var fileSize = FileUtils.GetFileSizeByFilePath(zipPath);
await Console.Out.WriteLineAsync($"Packaged: {zipPath}");
await Console.Out.WriteLineAsync($"Publishing {packageId} ({fileSize})...");
bool success;
(success, failureMessage) = await _apiService.PluginPublishAsync(plugin.Publisher, zipPath);
if (success)
{
await WriteUtils.PrintSuccessAsync($"Published {packageId}, your plugin will live at {CloudUtils.Www.GetPluginUrl(plugin.Publisher, plugin.Name)}.");
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
public void StaticEqualsTest1()
{
var v1 = new SemVersion(1, 2, 3);
var v2 = new SemVersion(1, 2, 3);
var r = SemVersion.Equals(v1, v2);
Assert.IsTrue(r);
}
public void Parse_V040()
{
var version = SemVersion.Parse("0.4.0").ToString();
Assert.AreEqual("0.4.0", version);
}
public void TestChangeBuild()
{
var v1 = new SemVersion(1, 2, 3, "alpha", "dev");
var v2 = v1.Change(build: "rel");
Assert.AreEqual(1, v2.Major);
Assert.AreEqual(2, v2.Minor);
Assert.AreEqual(3, v2.Patch);
Assert.AreEqual("alpha", v2.Prerelease);
Assert.AreEqual("rel", v2.Build);
}
public void GetHashCodeTest()
{
var version = new SemVersion(1).GetHashCode();
Assert.IsNotNull(version);
}
public void TestChangePrerelease()
{
var v1 = new SemVersion(1, 2, 3, "alpha", "dev");
var v2 = v1.Change(prerelease: "beta");
Assert.AreEqual(1, v2.Major);
Assert.AreEqual(2, v2.Minor);
Assert.AreEqual(3, v2.Patch);
Assert.AreEqual("beta", v2.Prerelease);
Assert.AreEqual("dev", v2.Build);
}
public void CtorNull()
{
var v = new SemVersion(1, 0, 0, null, null);
Assert.AreEqual("1.0.0", v.ToString());
}
public void TestUntypedCompareTo()
{
var v1 = new SemVersion(1);
var c = v1.CompareTo((object)v1);
Assert.AreEqual(0, c);
}
public void Test()
{
SemVersion.Parse("test");
// expect wrong input
}
public void UnequalOperatorTest()
{
var v1 = new SemVersion(1);
var v2 = new SemVersion(2);
var r = v1 != v2;
Assert.IsTrue(r);
}
private void Run()
{
if (ShowVersion)
{
if (SemVersion.TryParse(
FileVersionInfo.GetVersionInfo(typeof(Program).Assembly.Location).ProductVersion,
out var toolVersion))
{
WriteLine(toolVersion);
}
else
{
WriteLine(typeof(Program).Assembly.GetName().Version.ToString(3));
}
return;
}
var currentDirectory = new DirectoryInfo(Directory.GetCurrentDirectory());
var projectFile = !string.IsNullOrWhiteSpace(ProjectFilePath)
? new FileInfo(ProjectFilePath)
: currentDirectory.EnumerateFiles("*.csproj").FirstOrDefault();
if (projectFile is null ||
projectFile.Exists == false)
{
throw new CliException(1, $"Unable to find a project file in directory '{currentDirectory}'.");
}
var projectFileFullName = projectFile.FullName;
var xDocument = XDocument.Load(projectFileFullName);
var versionElement = xDocument.Root?.Descendants("Version").FirstOrDefault();
var currentVersion = ParseVersion(versionElement?.Value ?? "0.0.0");
WriteLine($"Current version: {currentVersion}");
if (Show)
{
return;
}
SemVersion version = null;
if (!string.IsNullOrWhiteSpace(NewVersion))
{
version = ParseVersion(NewVersion);
}
else
{
if (Major)
{
version = currentVersion.Change(
currentVersion.Major + 1,
0,
0,
"",
"");
}
else if (Minor)
{
version = currentVersion.Change(
minor: currentVersion.Minor + 1,
patch: 0,
prerelease: "",
build: "");
}
else if (Patch)
{
version = currentVersion.Change(
patch: currentVersion.Patch + 1,
prerelease: "",
build: "");
}
if (ReleaseCandidate)
{
version = (version ?? currentVersion).Change(
prerelease: CreatePreReleaseString(
ReleaseCandidateString,
version is null ? currentVersion.Prerelease : ""),
build: "");
}
else if (Beta)
{
if (version is null &&
currentVersion.Prerelease.StartsWith(ReleaseCandidateString,
StringComparison.OrdinalIgnoreCase))
{
throw new CliException(1,
"Can't increment beta version number of a release candidate version number.");
}
version = (version ?? currentVersion).Change(
prerelease: CreatePreReleaseString(BetaString,
version is null ? currentVersion.Prerelease : ""),
build: "");
}
else if (Alpha)
{
if (version is null &&
currentVersion.Prerelease.StartsWith(ReleaseCandidateString,
StringComparison.OrdinalIgnoreCase))
{
throw new CliException(1,
"Can't increment alpha version number of a release candidate version number.");
}
if (version is null &&
currentVersion.Prerelease.StartsWith(BetaString, StringComparison.OrdinalIgnoreCase))
{
throw new CliException(1, "Can't increment alpha version number of a beta version number.");
}
version = (version ?? currentVersion).Change(
prerelease: CreatePreReleaseString(AlphaString,
version is null ? currentVersion.Prerelease : ""),
build: "");
}
}
if (version is null)
{
var inputVersion = Prompt.GetString("New version:");
version = ParseVersion(inputVersion);
}
else
{
WriteLine($"New version: {version}");
}
if (versionElement is null)
{
var propertyGroupElement = xDocument.Root?.Descendants("PropertyGroup").FirstOrDefault();
if (propertyGroupElement is null)
{
propertyGroupElement = new XElement("PropertyGroup");
xDocument.Root?.Add(propertyGroupElement);
}
propertyGroupElement.Add(new XElement("Version", version));
}
else
{
versionElement.Value = version.ToString();
}
File.WriteAllText(projectFileFullName, xDocument.ToString());
if (!NoGit)
{
if (string.IsNullOrWhiteSpace(ProjectFilePath))
{
try
{
var tag = $"{GitVersionPrefix}{version}";
var message = !string.IsNullOrWhiteSpace(CommitMessage)
? CommitMessage
: tag;
Process.Start(new ProcessStartInfo("git", $"commit -am \"{message}\"")
{
RedirectStandardError = true,
RedirectStandardOutput = true,
})?.WaitForExit();
if (!NoGitTag)
{
// Hack to make sure the wrong commit is tagged
Thread.Sleep(200);
Process.Start(new ProcessStartInfo("git", $"tag {tag}")
{
RedirectStandardError = true,
RedirectStandardOutput = true,
})?.WaitForExit();
}
}
catch
{
/* Ignored */
}
}
else
{
WriteLine(
"Not running git integration when project file has been specified, to prevent running git in wrong directory.");
}
}
WriteLine($"Successfully set version to {version}");
}
public void CompareTestWithStrings1()
{
Assert.True(SemVersion.Equals("1.0.0", "1"));
}
/// <summary> /// Gets the initial state corresponding to a version. /// </summary> private static string GetInitState(SemVersion version) => InitPrefix + version + InitSuffix;
public override void Deserialize(IDataReader reader, SemVersion archiveVersion)
{
Value = reader.ReadDouble();
}
public void CIBuildVersion_LastReleaseBased_are_correctely_ordered(string tag)
{
ReleaseTagFormat formatV2 = ReleaseTagFormat.NugetPackageV2;
var t = ReleaseTagVersion.TryParse(tag);
var v = SemVersion.Parse(t.ToString(ReleaseTagFormat.SemVer), true);
var tNext = new ReleaseTagVersion(t.OrderedVersion + 1);
var vNext = SemVersion.Parse(tNext.ToString(ReleaseTagFormat.SemVer), true);
var tPrev = new ReleaseTagVersion(t.OrderedVersion - 1);
var vPrev = SemVersion.Parse(tPrev.ToString(ReleaseTagFormat.SemVer), true);
Assert.That(vPrev < v, "{0} < {1}", vPrev, v);
Assert.That(v < vNext, "{0} < {1}", v, vNext);
var sNuGet = t.ToString(formatV2);
var sNuGetPrev = tPrev.ToString(formatV2);
var sNuGetNext = tNext.ToString(formatV2);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetPrev, sNuGet) < 0, "{0} < {1}", sNuGetPrev, sNuGet);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGet, sNuGetNext) < 0, "{0} < {1}", sNuGet, sNuGetNext);
CIBuildDescriptor ci = new CIBuildDescriptor {
BranchName = "dev", BuildIndex = 1
};
string sCI = t.ToString(ReleaseTagFormat.SemVer, ci);
SemVersion vCi = SemVersion.Parse(sCI, true);
Assert.That(v < vCi, "{0} < {1}", v, vCi);
Assert.That(vCi < vNext, "{0} < {1}", vCi, vNext);
var sNuGetCI = t.ToString(formatV2, ci);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGet, sNuGetCI) < 0, "{0} < {1}", sNuGet, sNuGetCI);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCI, sNuGetNext) < 0, "{0} < {1}", sNuGetCI, sNuGetNext);
string sCiNext = tNext.ToString(ReleaseTagFormat.SemVer, ci);
SemVersion vCiNext = SemVersion.Parse(sCiNext, true);
Assert.That(vCiNext > vCi, "{0} > {1}", vCiNext, vCi);
Assert.That(vCiNext > vNext, "{0} > {1}", vCiNext, vNext);
var sNuGetCINext = tNext.ToString(formatV2, ci);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCINext, sNuGetCI) > 0, "{0} > {1}", sNuGetCINext, sNuGetCI);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCINext, sNuGetNext) > 0, "{0} > {1}", sNuGetCINext, sNuGetNext);
string sCiPrev = tPrev.ToString(ReleaseTagFormat.SemVer, ci);
SemVersion vCiPrev = SemVersion.Parse(sCiPrev, true);
Assert.That(vCiPrev > vPrev, "{0} > {1}", vCiPrev, vPrev);
Assert.That(vCiPrev < v, "{0} < {1}", vCiPrev, v);
Assert.That(vCiPrev < vCiNext, "{0} < {1}", vCiPrev, vCiNext);
var sNuGetCIPrev = tPrev.ToString(formatV2, ci);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCIPrev, sNuGetPrev) > 0, "{0} > {1}", sNuGetCIPrev, sNuGetPrev);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCIPrev, sNuGet) < 0, "{0} < {1}", sNuGetCIPrev, sNuGet);
Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCIPrev, sNuGetCINext) < 0, "{0} < {1}", sNuGetCIPrev, sNuGetCINext);
}