public void CompareToWorksCorrectly(KspVersion v1, KspVersion v2, int comparison)
{
// Act
var genericCompareTo = v1.CompareTo(v2);
var nonGenericCompareTo = v1.CompareTo((object)v2);
var lessThanOperator = v1 < v2;
var lessThanOrEqualOperator = v1 <= v2;
var greaterThanOperator = v1 > v2;
var greaterThanOrEqualOperator = v1 >= v2;
var reverseGenericCompareTo = v2.CompareTo(v1);
var reverseNonGenericCompareTo = v2.CompareTo((object)v1);
var reverseLessThanOperator = v2 < v1;
var reverseLessThanOrEqualOperator = v2 <= v1;
var reverseGreaterThanOperator = v2 > v1;
var reverseGreaterThanOrEqualOperator = v2 >= v1;
// Assert
Assert.AreEqual(Math.Sign(comparison), Math.Sign(genericCompareTo));
Assert.AreEqual(Math.Sign(comparison), Math.Sign(nonGenericCompareTo));
Assert.AreEqual(comparison < 0, lessThanOperator);
Assert.AreEqual(comparison <= 0, lessThanOrEqualOperator);
Assert.AreEqual(comparison > 0, greaterThanOperator);
Assert.AreEqual(comparison >= 0, greaterThanOrEqualOperator);
Assert.AreEqual(-Math.Sign(comparison), Math.Sign(reverseGenericCompareTo));
Assert.AreEqual(-Math.Sign(comparison), Math.Sign(reverseNonGenericCompareTo));
Assert.AreEqual(comparison > 0, reverseLessThanOperator);
Assert.AreEqual(comparison >= 0, reverseLessThanOrEqualOperator);
Assert.AreEqual(comparison < 0, reverseGreaterThanOperator);
Assert.AreEqual(comparison <= 0, reverseGreaterThanOrEqualOperator);
}
/// <summary>
/// Find the minimum and maximum mod versions and compatible game versions
/// for a list of modules (presumably different versions of the same mod).
/// </summary>
/// <param name="modVersions">The modules to inspect</param>
/// <param name="minMod">Return parameter for the lowest mod version</param>
/// <param name="maxMod">Return parameter for the highest mod version</param>
/// <param name="minKsp">Return parameter for the lowest game version</param>
/// <param name="maxKsp">Return parameter for the highest game version</param>
public static void GetMinMaxVersions(IEnumerable <CkanModule> modVersions,
out ModuleVersion minMod, out ModuleVersion maxMod,
out KspVersion minKsp, out KspVersion maxKsp)
{
minMod = maxMod = null;
minKsp = maxKsp = null;
foreach (CkanModule rel in modVersions.Where(v => v != null))
{
if (minMod == null || minMod > rel.version)
{
minMod = rel.version;
}
if (maxMod == null || maxMod < rel.version)
{
maxMod = rel.version;
}
KspVersion relMin = rel.EarliestCompatibleKSP();
KspVersion relMax = rel.LatestCompatibleKSP();
if (minKsp == null || !minKsp.IsAny && (minKsp > relMin || relMin.IsAny))
{
minKsp = relMin;
}
if (maxKsp == null || !maxKsp.IsAny && (maxKsp < relMax || relMax.IsAny))
{
maxKsp = relMax;
}
}
}
public void GetsInternalAvcCorrectly()
{
//Arrange
var json = new JObject();
json["spec_version"] = 1;
json["identifier"] = "DogeCoinFlag";
json["version"] = "1.0.0";
json["download"] = "https://awesomemod.example/AwesomeMod.zip";
var sut = new ModuleService();
// Act
var result = sut.GetInternalAvc(CkanModule.FromJson(json.ToString()), TestData.DogeCoinFlagAvcZip());
// Assert
Assert.That(result, Is.Not.Null,
"ModuleService should get an internal AVC file."
);
Assert.That(result.version, Is.EqualTo(new Version("1.1.0.0")),
"ModuleService should get correct version from the internal AVC file."
);
Assert.That(result.ksp_version, Is.EqualTo(KspVersion.Parse("0.24.2")),
"ModuleService should get correct ksp_version from the internal AVC file."
);
Assert.That(result.ksp_version_min, Is.EqualTo(KspVersion.Parse("0.24.0")),
"ModuleService should get correct ksp_version_min from the internal AVC file."
);
Assert.That(result.ksp_version_max, Is.EqualTo(KspVersion.Parse("0.24.2")),
"ModuleService should get correct ksp_version_max from the internal AVC file."
);
}
public void CompareToThrowsOnNullParameters()
{
// Act
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
// ReSharper disable UnusedVariable
TestDelegate actGenericCompareTo = () => new KspVersion().CompareTo(null);
TestDelegate actNonGenericCompareTo = () => new KspVersion().CompareTo((object)null);
TestDelegate lessThanOperatorNullLeft = () => { var _ = null < new KspVersion(); };
TestDelegate lessThanOperatorNullRight = () => { var _ = new KspVersion() < null; };
TestDelegate lessThanOrEqualOperatorNullLeft = () => { var _ = null <= new KspVersion(); };
TestDelegate lessThanOrEqualOperatorNullRight = () => { var _ = new KspVersion() <= null; };
TestDelegate greaterThanOperatorNullLeft = () => { var _ = null > new KspVersion(); };
TestDelegate greaterThanOperatorNullRight = () => { var _ = new KspVersion() > null; };
TestDelegate greaterThanOrEqualOperatorNullLeft = () => { var _ = null >= new KspVersion(); };
TestDelegate greaterThanOrEqualOperatorNullRight = () => { var _ = new KspVersion() >= null; };
// ReSharper restore UnusedVariable
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
// Assert
Assert.That(actGenericCompareTo, Throws.Exception);
Assert.That(actNonGenericCompareTo, Throws.Exception);
Assert.That(lessThanOperatorNullLeft, Throws.Exception);
Assert.That(lessThanOperatorNullRight, Throws.Exception);
Assert.That(lessThanOrEqualOperatorNullLeft, Throws.Exception);
Assert.That(lessThanOrEqualOperatorNullRight, Throws.Exception);
Assert.That(greaterThanOperatorNullLeft, Throws.Exception);
Assert.That(greaterThanOperatorNullRight, Throws.Exception);
Assert.That(greaterThanOrEqualOperatorNullLeft, Throws.Exception);
Assert.That(greaterThanOrEqualOperatorNullRight, Throws.Exception);
}
public bool TryGetVersion(string directory, out KspVersion result)
{
var buildIdPath = Path.Combine(directory, "buildID.txt");
if (File.Exists(buildIdPath))
{
var match = File
.ReadAllLines(buildIdPath)
.Select(i => BuildIdPattern.Match(i))
.FirstOrDefault(i => i.Success);
if (match != null)
{
var version = _kspBuildMap[match.Groups["buildid"].Value];
if (version != null)
{
result = version;
return(true);
}
}
}
result = default(KspVersion);
return(false);
}
public bool Compatible(KspVersion gameVersion, CkanModule module)
{
// If it's strictly compatible, then it's compatible.
if (strict.Compatible(gameVersion, module))
{
return(true);
}
// If we're in strict mode, and it's not strictly compatible, then it's
// not compatible.
if (module.ksp_version_strict)
{
return(false);
}
// Otherwise, check if it's "generally recognise as safe".
// If we're running KSP 1.0.4, then allow the mod to run if we would have
// considered it compatible under 1.0.3 (as 1.0.4 was "just a hotfix").
if (gameVersion.Equals(KspVersion.Parse("1.0.4")))
{
return(strict.Compatible(v103, module));
}
return(false);
}
private void AddVersionToListButton_Click(object sender, EventArgs e)
{
if (AddVersionToListTextBox.Text.Length == 0)
{
return;
}
if (AddVersionToListTextBox.Text.ToLower() == "any")
{
MessageBox.Show(
Properties.Resources.CompatibleKspVersionsDialogInvalidFormat,
Properties.Resources.CompatibleKspVersionsDialogErrorTitle,
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
return;
}
try
{
var version = KspVersion.Parse(AddVersionToListTextBox.Text);
SelectedVersionsCheckedListBox.Items.Insert(0, version);
}
catch (FormatException)
{
MessageBox.Show(
Properties.Resources.CompatibleKspVersionsDialogInvalidFormat,
Properties.Resources.CompatibleKspVersionsDialogErrorTitle,
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
}
}
/// <summary>
/// Returns true if our mod is compatible with the KSP version specified.
/// </summary>
public bool IsCompatibleKSP(KspVersion version)
{
log.DebugFormat("Testing if {0} is compatible with KSP {1}", this, version);
return(_comparator.Compatible(version, this));
}
public CkanModule GeneratorRandomModule(
KspVersion ksp_version = null,
List <RelationshipDescriptor> conflicts = null,
List <RelationshipDescriptor> depends = null,
List <RelationshipDescriptor> sugests = null,
List <String> provides = null,
string identifier = null,
Version version = null)
{
var mod = new CkanModule
{
name = Generator.Next().ToString(CultureInfo.InvariantCulture),
@abstract = Generator.Next().ToString(CultureInfo.InvariantCulture),
identifier = identifier ?? Generator.Next().ToString(CultureInfo.InvariantCulture),
spec_version = new Version(1.ToString(CultureInfo.InvariantCulture)),
ksp_version = ksp_version ?? KspVersion.Parse("0." + Generator.Next()),
version = version ?? new Version(Generator.Next().ToString(CultureInfo.InvariantCulture))
};
mod.ksp_version_max = mod.ksp_version_min = null;
mod.conflicts = conflicts;
mod.depends = depends;
mod.suggests = sugests;
mod.provides = provides;
return(mod);
}
public void FakeInstance_ValidArgumentsWithDLCs_ManagerHasValidInstance()
{
string name = "testname";
KspVersion mhVersion = KspVersion.Parse("1.1.0");
KspVersion bgVersion = KspVersion.Parse("1.0.0");
string tempdir = TestData.NewTempDir();
KspVersion version = KspVersion.Parse("1.7.1");
Dictionary <CKAN.DLC.IDlcDetector, KspVersion> dlcs = new Dictionary <CKAN.DLC.IDlcDetector, KspVersion>()
{
{ new CKAN.DLC.MakingHistoryDlcDetector(), mhVersion },
{ new CKAN.DLC.BreakingGroundDlcDetector(), bgVersion }
};
manager.FakeInstance(name, tempdir, version, dlcs);
CKAN.KSP newKSP = new CKAN.KSP(tempdir, name, new NullUser());
CKAN.DLC.MakingHistoryDlcDetector mhDetector = new CKAN.DLC.MakingHistoryDlcDetector();
CKAN.DLC.BreakingGroundDlcDetector bgDetector = new CKAN.DLC.BreakingGroundDlcDetector();
Assert.IsTrue(manager.HasInstance(name));
Assert.IsTrue(mhDetector.IsInstalled(newKSP, out string _, out UnmanagedModuleVersion detectedMhVersion));
Assert.IsTrue(bgDetector.IsInstalled(newKSP, out string _, out UnmanagedModuleVersion detectedBgVersion));
Assert.IsTrue(detectedMhVersion == new UnmanagedModuleVersion(mhVersion.ToString()));
Assert.IsTrue(detectedBgVersion == new UnmanagedModuleVersion(bgVersion.ToString()));
// Tidy up.
CKAN.RegistryManager.Instance(newKSP).ReleaseLock();
System.IO.Directory.Delete(tempdir, true);
}
public void CompatibleModules_PastAndFutureCompatibility_ReturnsCurrentOnly()
{
// Arrange
CkanModule modFor161 = CkanModule.FromJson(@"{
""identifier"": ""TypicalMod"",
""version"": ""0.9.0"",
""download"": ""https://kerbalstuff.com/mod/269/Dogecoin%20Flag/download/1.01"",
""ksp_version"": ""1.6.1""
}");
CkanModule modFor173 = CkanModule.FromJson(@"{
""identifier"": ""TypicalMod"",
""version"": ""1.0.0"",
""download"": ""https://kerbalstuff.com/mod/269/Dogecoin%20Flag/download/1.01"",
""ksp_version"": ""1.7.3""
}");
CkanModule modFor181 = CkanModule.FromJson(@"{
""identifier"": ""TypicalMod"",
""version"": ""1.1.0"",
""download"": ""https://kerbalstuff.com/mod/269/Dogecoin%20Flag/download/1.01"",
""ksp_version"": ""1.8.1""
}");
registry.AddAvailable(modFor161);
registry.AddAvailable(modFor173);
registry.AddAvailable(modFor181);
// Act
KspVersionCriteria v173 = new KspVersionCriteria(KspVersion.Parse("1.7.3"));
List <CkanModule> compat = registry.CompatibleModules(v173).ToList();
// Assert
Assert.IsFalse(compat.Contains(modFor161));
Assert.IsTrue(compat.Contains(modFor173));
Assert.IsFalse(compat.Contains(modFor181));
}
public KspVersion Version()
{
if (version == null)
{
version = DetectVersion(GameDir());
}
return(version);
}
public void ToVersionRangeWorksCorrectly(KspVersion version, KspVersionRange expectedRange)
{
// Act
var result = version.ToVersionRange();
// Assert
Assert.AreEqual(expectedRange, result);
}
public void ReadJsonWorksCorrectly(string json, KspVersion expected)
{
// Act
var result = JsonConvert.DeserializeObject <TestPoco>(json);
// Assert
Assert.That(result.KspVersion, Is.EqualTo(expected));
}
/// <summary>
/// Initialize the popup
/// </summary>
public CompatibleVersionDialog() : base()
{
int l = GetLeft(),
r = GetRight();
int t = GetTop(),
b = GetBottom();
choices = new ConsoleListBox <KspVersion>(
l + 2, t + 2, r - 2, b - 4,
options,
new List <ConsoleListBoxColumn <KspVersion> >()
{
new ConsoleListBoxColumn <KspVersion>()
{
Header = "Predefined Version",
Width = r - l - 5,
Renderer = v => v.ToString(),
Comparer = (v1, v2) => v1.CompareTo(v2)
}
},
0, 0, ListSortDirection.Descending
);
AddObject(choices);
choices.AddTip("Enter", "Select version");
choices.AddBinding(Keys.Enter, (object sender) => {
choice = choices.Selection;
return(false);
});
manualEntry = new ConsoleField(
l + 2, b - 2, r - 2
)
{
GhostText = () => "<Enter a version>"
};
AddObject(manualEntry);
manualEntry.AddTip("Enter", "Accept value", () => KspVersion.TryParse(manualEntry.Value, out choice));
manualEntry.AddBinding(Keys.Enter, (object sender) => {
if (KspVersion.TryParse(manualEntry.Value, out choice))
{
// Good value, done running
return(false);
}
else
{
// Not valid, so they can't even see the key binding
return(true);
}
});
AddTip("Esc", "Cancel");
AddBinding(Keys.Escape, (object sender) => {
choice = null;
return(false);
});
CenterHeader = () => "Select Compatible Version";
}
public void MissingPatch_VersionOnlyHasMajorMinor()
{
var converter = new JsonAvcToKspVersion();
string json = @"{""MAJOR"":1, ""MINOR"":5}";
var reader = new JsonTextReader(new StringReader(json));
var result = (KspVersion)converter.ReadJson(reader, null, null, null);
Assert.That(result, Is.EqualTo(KspVersion.Parse("1.5")));
}
/// <summary>
/// Attempts to convert the module_names to ckan modules via CkanModule.FromIDandVersion and then calls RelationshipResolver.ctor(IEnumerable{CkanModule}, Registry, KSPVersion)"/>
/// </summary>
/// <param name="module_names"></param>
/// <param name="options"></param>
/// <param name="registry"></param>
/// <param name="kspversion"></param>
public RelationshipResolver(IEnumerable <string> module_names, RelationshipResolverOptions options, IRegistryQuerier registry,
KspVersion kspversion) :
this(module_names.Select(name => CkanModule.FromIDandVersion(registry, name, kspversion)).ToList(),
options,
registry,
kspversion)
{
// Does nothing, just calls the other overloaded constructor
}
public void ParseWorksCorrectly(string s, KspVersion version)
{
// Act
var result = KspVersion.Parse(s);
// Assert
Assert.AreEqual(version, result);
Assert.AreEqual(s, result.ToString());
}
public void ParseThrowsExceptionOnInvalidParameter(string s)
{
// Act
// ReSharper disable once ObjectCreationAsStatement
TestDelegate act = () => KspVersion.Parse(s);
// Assert
Assert.That(act, Throws.Exception);
}
public void TryParseReturnsFalseOnInvalidParameter(string s)
{
// Act
KspVersion result;
var success = KspVersion.TryParse(s, out result);
// Assert
Assert.IsFalse(success);
}
/// <summary>
/// <see cref = "IRegistryQuerier.LatestAvailableWithProvides" />
/// </summary>
public List <CkanModule> LatestAvailableWithProvides(string module, KspVersion ksp_version, RelationshipDescriptor relationship_descriptor = null)
{
// This public interface calculates a cache of modules which
// are compatible with the current version of KSP, and then
// calls the private version below for heavy lifting.
return(LatestAvailableWithProvides(module, ksp_version,
available_modules.Values.Select(pair => pair.Latest(ksp_version)).Where(mod => mod != null).ToArray(),
relationship_descriptor));
}
public void UpdateRegistryZip()
{
CKAN.Repo.UpdateRegistry(TestData.TestKANZip(), registry, ksp.KSP, new NullUser());
// Test we've got an expected module.
CkanModule far = registry.LatestAvailable("FerramAerospaceResearch", KspVersion.Parse("0.25.0"));
Assert.AreEqual("v0.14.3.2", far.version.ToString());
}
public void TestStrictGameComparator(String modVersion, String gameVersion, bool expectedResult)
{
var comparator = new CKAN.StrictGameComparator();
// We're going to tweak compatibly of the mod
gameMod.ksp_version = KspVersion.Parse(modVersion);
// Now test!
Assert.AreEqual(expectedResult, comparator.Compatible(new KspVersionCriteria(KspVersion.Parse(gameVersion)), gameMod));
}
public KspVersion this[string buildId]
{
get
{
EnsureBuildMap();
string version;
return(_jBuilds.Builds.TryGetValue(buildId, out version) ? KspVersion.Parse(version) : null);
}
}
/// <summary>
/// Create a new fake KSP instance
/// </summary>
/// <param name="new_name">The name for the new instance.</param>
/// <param name="new_path">The loaction of the new instance.</param>
/// <param name="version">The version of the new instance. Should have a build number.</param>
/// <param name="dlcVersion">The version of the DLC. Null if DLC should be faked.</param>
public void FakeInstance(string new_name, string new_path, KspVersion version, string dlcVersion = null)
{
if (!version.InBuildMap())
{
throw new IncorrectKSPVersionKraken(String.Format("The specified KSP version is not a known version: {0}", version.ToString()));
}
if (Directory.Exists(new_path) && (Directory.GetFiles(new_path).Length != 0 || Directory.GetDirectories(new_path).Length != 0))
{
throw new BadInstallLocationKraken("The specified folder already exists and is not empty.");
}
try
{
log.DebugFormat("Creating folder structure and text files at {0} for KSP version {1}", Path.GetFullPath(new_path), version.ToString());
// Create a KSP root directory, containing a GameData folder, a buildID.txt/buildID64.txt and a readme.txt
Directory.CreateDirectory(new_path);
Directory.CreateDirectory(Path.Combine(new_path, "GameData"));
Directory.CreateDirectory(Path.Combine(new_path, "Ships"));
Directory.CreateDirectory(Path.Combine(new_path, "Ships", "VAB"));
Directory.CreateDirectory(Path.Combine(new_path, "Ships", "SPH"));
Directory.CreateDirectory(Path.Combine(new_path, "Ships", "@thumbs"));
Directory.CreateDirectory(Path.Combine(new_path, "Ships", "@thumbs", "VAB"));
Directory.CreateDirectory(Path.Combine(new_path, "Ships", "@thumbs", "SPH"));
// Don't write the buildID.txts if we have no build, otherwise it would be -1.
if (version.IsBuildDefined)
{
File.WriteAllText(Path.Combine(new_path, "buildID.txt"), String.Format("build id = {0}", version.Build));
File.WriteAllText(Path.Combine(new_path, "buildID64.txt"), String.Format("build id = {0}", version.Build));
}
// Create the readme.txt WITHOUT build number.
File.WriteAllText(Path.Combine(new_path, "readme.txt"), String.Format("Version {0}", new KspVersion(version.Major, version.Minor, version.Patch).ToString()));
// If a installed DLC should be simulated, we create the needed folder structure and the readme.txt
if (!String.IsNullOrEmpty(dlcVersion) && version.CompareTo(new KspVersion(1, 4, 0)) >= 0)
{
Directory.CreateDirectory(Path.Combine(new_path, "GameData", "SquadExpansion", "MakingHistory"));
File.WriteAllText(
Path.Combine(new_path, "GameData", "SquadExpansion", "MakingHistory", "readme.txt"),
String.Format("Version {0}", dlcVersion));
}
// Add the new instance to the registry
KSP new_instance = new KSP(new_path, new_name, User);
AddInstance(new_instance);
}
// Thrown by AddInstance() if created instance is not valid.
// Thrown f.e. if a write operation didn't complete for unknown reasons.
catch (NotKSPDirKraken kraken)
{
throw kraken;
}
}
/// <summary>
/// Return the most recent release of a module with a optional ksp version to target and a RelationshipDescriptor to satisfy.
/// </summary>
/// <param name="ksp_version">If not null only consider mods which match this ksp version.</param>
/// <param name="relationship">If not null only consider mods which satisfy the RelationshipDescriptor.</param>
/// <returns></returns>
public CkanModule Latest(KspVersion ksp_version = null, RelationshipDescriptor relationship = null)
{
var available_versions = new List <Version>(module_version.Keys);
CkanModule module;
log.DebugFormat("Our dictionary has {0} keys", module_version.Keys.Count);
log.DebugFormat("Choosing between {0} available versions", available_versions.Count);
// Uh oh, nothing available. Maybe this existed once, but not any longer.
if (available_versions.Count == 0)
{
return(null);
}
// No restrictions? Great, we can just pick the first one!
if (ksp_version == null && relationship == null)
{
module = module_version[available_versions.First()];
log.DebugFormat("No KSP version restriction, {0} is most recent", module);
return(module);
}
// If there's no relationship to satisfy, we can just pick the first that is
// compatible with our version of KSP.
if (relationship == null)
{
// Time to check if there's anything that we can satisfy.
var version =
available_versions.FirstOrDefault(v => module_version[v].IsCompatibleKSP(ksp_version));
if (version != null)
{
return(module_version[version]);
}
log.DebugFormat("No version of {0} is compatible with KSP {1}",
module_version[available_versions[0]].identifier, ksp_version);
return(null);
}
// If we're here, then we have a relationship to satisfy, so things get more complex.
if (ksp_version == null)
{
var version = available_versions.FirstOrDefault(relationship.version_within_bounds);
return(version == null ? null : module_version[version]);
}
else
{
var version = available_versions.FirstOrDefault(v =>
relationship.version_within_bounds(v) &&
module_version[v].IsCompatibleKSP(ksp_version));
return(version == null ? null : module_version[version]);
}
}
public void VersionSpan_FiniteRange_CorrectString()
{
// Arrange
KspVersion min = new KspVersion(1, 0, 0);
KspVersion max = new KspVersion(1, 1, 1);
// Act
string s = KspVersionRange.VersionSpan(min, max);
// Assert
Assert.AreEqual("KSP 1.0.0 - 1.1.1", s);
}
public void VersionSpan_MaxOnly_CorrectString()
{
// Arrange
KspVersion min = KspVersion.Any;
KspVersion max = new KspVersion(1, 0, 0);
// Act
string s = KspVersionRange.VersionSpan(min, max);
// Assert
Assert.AreEqual("KSP 1.0.0 and earlier", s);
}
public void VersionSpan_OneOnly_CorrectString()
{
// Arrange
KspVersion min = new KspVersion(1, 0, 0);
KspVersion max = new KspVersion(1, 0, 0);
// Act
string s = KspVersionRange.VersionSpan(min, max);
// Assert
Assert.AreEqual("KSP 1.0.0", s);
}
public void VersionSpan_AllVersions_CorrectString()
{
// Arrange
KspVersion min = KspVersion.Any;
KspVersion max = KspVersion.Any;
// Act
string s = KspVersionRange.VersionSpan(min, max);
// Assert
Assert.AreEqual("KSP all versions", s);
}
