/// <summary>
/// Creates an instance of a particular comparer for a given <see cref="RomComparison"/> mode.
/// </summary>
/// <param name="comparison">The desired comparison mode.</param>
/// <returns>A new instance of the comparison implementation. Comparer-specific features may be used if so desired.</returns>
public static RomComparer GetComparer(RomComparison comparison)
{
RomComparer comparer = null;
switch (comparison)
{
case RomComparison.Strict:
comparer = new RomComparerStrict();
break;
case RomComparison.StrictRomCrcOnly:
comparer = new RomComparerStrictCrcOnly();
break;
#if CANONICAL_COMPARE_SUPPORTED
case RomComparison.CanonicalStrict:
comparer = new CanonicalRomComparerStrict();
break;
case RomComparison.CanonicalRomCrcOnly:
comparer = new CanonicalRomComparer();
break;
#endif // CANONICAL_COMPARE_SUPPORTED
default:
throw new ArgumentException(string.Format(Resources.Strings.RomComparer_InvalidCompareRequestedFormat, comparison), "comparison");
}
return(comparer);
}
public void RomComparer_CompareNullToNullAsIRoms_ProducesCorrectResult(RomComparison comparisonMode)
{
IRom rom0 = null;
IRom rom1 = null;
using (var comparer = RomComparer.GetComparer(comparisonMode))
{
Assert.Equal(0, comparer.Compare(rom0, rom1));
}
}
public void RomComparer_CompareNullToRomsAsObjects_ProducesCorrectResult(RomComparison comparisonMode)
{
var romPath = RomComparerTestStorageAccess.Initialize(TestRomResources.TestRomPath).First();
object rom0 = null;
object rom1 = Rom.Create(romPath, null);
using (var comparer = RomComparer.GetComparer(comparisonMode))
{
Assert.Equal(-1, comparer.Compare(rom0, rom1));
}
}
public void RomComparer_CompareTwoSameRomsAsObjects_ProducesCorrectResult(RomComparison comparisonMode)
{
var paths = RomComparerTestStorageAccess.Initialize(TestRomResources.TestRomPath, TestRomResources.TestRomPath);
Assert.NotEqual(paths[0], paths[1]);
object rom0 = Rom.Create(paths[0], null);
object rom1 = Rom.Create(paths[1], null);
using (var comparer = RomComparer.GetComparer(comparisonMode))
{
Assert.Equal(0, comparer.Compare(rom0, rom1));
}
}
public void RomComparer_GetComparerForMode_BehavesAsExpected(RomComparison comparisonMode, Type expectedComparisonType, bool shouldThrowArgumentException)
{
if (shouldThrowArgumentException)
{
Assert.Throws <ArgumentException>(() => RomComparer.GetComparer(comparisonMode));
}
else
{
var comparer = RomComparer.GetComparer(comparisonMode);
Assert.NotNull(comparer);
Assert.True(expectedComparisonType.IsInstanceOfType(comparer));
}
}
public void RomComparer_GetDefaultComparerForMode_BehavesAsExpected(RomComparison comparisonMode, RomComparer expectedComparer, bool shouldThrowArgumentException)
{
if (shouldThrowArgumentException)
{
Assert.Throws <ArgumentException>(() => RomComparer.GetDefaultComparerForMode(comparisonMode));
}
else
{
var comparer = RomComparer.GetDefaultComparerForMode(comparisonMode);
Assert.NotNull(comparer);
Assert.True(object.ReferenceEquals(expectedComparer, comparer));
}
}
/// <summary>
/// Inspects two ROMs and determines if they are the same ROM, to the best it is capable of doing.
/// </summary>
/// <param name="rom">The reference ROM.</param>
/// <param name="otherRom">The ROM to compare with.</param>
/// <param name="programInfo">Program information used for comparison.</param>
/// <param name="comparisonMode">Specifies the <see cref="RomComparison"/> mode to use to determine equivalence.</param>
/// <returns>If the two ROMs are equivalent, returns <c>true</c>, otherwise returns <c>false</c>.</returns>
/// <remarks>Because the same ROM may be packaged in up to three different file formats at this time (.bin + .cfg, .rom, and .luigi), it can be difficult to
/// determine if two ROMs are, indeed, the same. The <paramref name="comparisonMode"/> defines how to compare the two ROMs</remarks>
public static bool IsEquivalentTo(this IRom rom, IRom otherRom, IProgramInformation programInfo, RomComparison comparisonMode)
{
var equivalent = object.ReferenceEquals(rom, otherRom);
if (!equivalent)
{
var comparer = RomComparer.GetComparer(comparisonMode);
equivalent = rom.IsEquivalentTo(otherRom, programInfo, comparer);
}
return(equivalent);
}
/// <summary>
/// Compares two ROMs using the specified compare implementation.
/// </summary>
/// <param name="rom">The 'reference' ROM to compare against.</param>
/// <param name="otherRom">The ROM to compare to <paramref name="rom"/>.</param>
/// <param name="comparisonMode">One of the <see cref="RomComparison"/> mode values. Based on this value, the appropriate default implementation of <see cref="RomComparer"/> will be used.</param>
/// <returns><c>true</c> if <paramref name="rom"/> and <paramref name="otherRom"/> are considered equal using <paramref name="comparisonMode"/>.</returns>
public static bool IsEquivalentTo(this IRom rom, IRom otherRom, RomComparison comparisonMode)
{
return(rom.IsEquivalentTo(otherRom, null, comparisonMode));
}
