private void VerifyMetadata(IProgramInformation expectedInformation, UserSpecifiedProgramInformation information)
{
var expectedMetadata = expectedInformation as IProgramMetadata;
if (expectedMetadata == null)
{
var emptyStringData = Enumerable.Empty <string>();
Assert.Equal(string.IsNullOrEmpty(expectedInformation.Title) ? emptyStringData : new[] { expectedInformation.Title }, information.LongNames);
Assert.Equal(string.IsNullOrEmpty(expectedInformation.ShortName) ? emptyStringData : new[] { expectedInformation.ShortName }, information.ShortNames);
Assert.Equal(emptyStringData, information.Descriptions);
Assert.Equal(string.IsNullOrEmpty(expectedInformation.Vendor) ? emptyStringData : new[] { expectedInformation.Vendor }, information.Publishers);
Assert.Equal(emptyStringData, information.Programmers);
Assert.Equal(emptyStringData, information.Designers);
Assert.Equal(emptyStringData, information.Graphics);
Assert.Equal(emptyStringData, information.Music);
Assert.Equal(emptyStringData, information.SoundEffects);
Assert.Equal(emptyStringData, information.Voices);
Assert.Equal(emptyStringData, information.Documentation);
Assert.Equal(emptyStringData, information.Artwork);
Assert.Equal(emptyStringData, information.Licenses);
Assert.Equal(emptyStringData, information.ContactInformation);
Assert.Equal(emptyStringData, information.Versions);
Assert.Equal(emptyStringData, information.AdditionalInformation);
var emptyDateData = Enumerable.Empty <MetadataDateTime>();
var expectedReleaseDateData = emptyDateData;
MetadataDateTime releaseDate;
var expectedYearString = GetExpectedYearString(expectedInformation.Year, out releaseDate);
if (releaseDate != MetadataDateTime.MinValue)
{
expectedReleaseDateData = new[] { releaseDate };
}
Assert.Equal(expectedReleaseDateData, information.ReleaseDates);
Assert.Equal(emptyDateData, information.BuildDates);
}
else
{
Assert.Equal(expectedMetadata.LongNames, information.LongNames);
Assert.Equal(expectedMetadata.ShortNames, information.ShortNames);
Assert.Equal(expectedMetadata.Descriptions, information.Descriptions);
Assert.Equal(expectedMetadata.Publishers, information.Publishers);
Assert.Equal(expectedMetadata.Programmers, information.Programmers);
Assert.Equal(expectedMetadata.Designers, information.Designers);
Assert.Equal(expectedMetadata.Graphics, information.Graphics);
Assert.Equal(expectedMetadata.Music, information.Music);
Assert.Equal(expectedMetadata.SoundEffects, information.SoundEffects);
Assert.Equal(expectedMetadata.Voices, information.Voices);
Assert.Equal(expectedMetadata.Documentation, information.Documentation);
Assert.Equal(expectedMetadata.Artwork, information.Artwork);
Assert.Equal(expectedMetadata.Licenses, information.Licenses);
Assert.Equal(expectedMetadata.ContactInformation, information.ContactInformation);
Assert.Equal(expectedMetadata.Versions, information.Versions);
var expectedAdditionalInformation = Enumerable.Range(0, expectedMetadata.AdditionalInformation.Count()).Zip(expectedMetadata.AdditionalInformation, (i, s) => string.Format(CultureInfo.CurrentCulture, "{0}: {1}", i, s));
Assert.Equal(expectedAdditionalInformation, information.AdditionalInformation);
Assert.Equal(expectedMetadata.ReleaseDates, information.ReleaseDates);
Assert.Equal(expectedMetadata.BuildDates, information.BuildDates);
}
}
public void UserSpecifiedProgramInformation_ConstructWithNonzeroCrc_CreatesInformationWithExpectedProgramTitle(string title, string expectedTitle)
{
var information = new UserSpecifiedProgramInformation(1u, title);
Assert.False(information.IsModified);
Assert.Equal(expectedTitle, information.Title);
}
public void UserSpecifiedProgramInformation_ConstructWithMetadataProgramInformationWithPopulatedMetadataFields_ContainsExpectedData(string shortName)
{
var sourceInformation = new TestProgramInformationMetadata()
{
Title = "Sumpin' Mysteriouser",
Vendor = "Somewhat Mysterious, Inc.",
Year = "1989",
ShortName = shortName,
Features = new ProgramFeaturesBuilder().WithEcsFeatures(EcsFeatures.Synthesizer).Build() as ProgramFeatures
};
sourceInformation.AddCrc(0x24680246, null, IncompatibilityFlags.KeyboardComponent);
sourceInformation.AddCrc(0x13579135, "(fast)", IncompatibilityFlags.Tutorvision);
sourceInformation.SetOrigin(ProgramInformationOrigin.UpdateFragment);
var dateTimeBuilder = new MetadataDateTimeBuilder(1999);
sourceInformation.AddReleaseDate(dateTimeBuilder.WithMonth(1).WithDay(2).Build());
sourceInformation.AddReleaseDate(dateTimeBuilder.WithDay(3).Build());
sourceInformation.AddBuildDate(dateTimeBuilder.WithDay(1).Build());
sourceInformation.AddBuildDate(dateTimeBuilder.WithDay(2).Build());
foreach (var fieldId in TestProgramInformationMetadata.StringFieldIds)
{
var stringValue = fieldId.ToString();
sourceInformation.AddMetadataValue(fieldId, stringValue + " #1");
sourceInformation.AddMetadataValue(fieldId, stringValue + " #2");
}
var information = new UserSpecifiedProgramInformation(sourceInformation);
Assert.False(information.IsModified);
VerifyInformation(sourceInformation, information);
}
public void UserSpecifiedProgramInformationTable_GroupWithExistingEntryWithOverlappingCrcs_MergesCrcs()
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/group_existing_with_overlapping_crcs_groups.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 6);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var entry = new UserSpecifiedProgramInformation(1, "My dev ROM");
entry.AddCrc(3);
entry.AddCrc(5);
Assert.True(database.AddEntry(entry));
var newEntry = new UserSpecifiedProgramInformation(2, "My other dev ROM");
newEntry.AddCrc(3);
newEntry.AddCrc(4);
newEntry.AddCrc(5);
newEntry.AddCrc(6);
Assert.True(database.GroupWithExistingEntry(newEntry, entry));
var expectedCrcs = new[] { 1u, 2u, 3u, 4u, 5u, 6u };
Assert.Equal(expectedCrcs, entry.Crcs.OrderBy(c => c.Crc).Select(c => c.Crc));
}
public void UserSpecifiedProgramInformation_ConstructWithAnotherUserSpecifiedProgramInformation_CreatesExpectedInformation()
{
var sourceInformation = new UserSpecifiedProgramInformation(12345, "Scoob!", "1966");
var information = new UserSpecifiedProgramInformation(sourceInformation);
Assert.False(information.IsModified);
VerifyInformation(sourceInformation, information);
}
public void UserProgramInformation_AddLongNameMetadata_AddsLongNameMetadata()
{
var information = new UserSpecifiedProgramInformation(2222u);
Assert.True(information.AddLongName(null));
Assert.False(information.AddLongName(null));
Assert.Equal(new string[] { ProgramInformation.UnknownProgramTitle, null }, information.LongNames);
}
public void UserProgramInformation_AddArtworkMetadata_AddsArtworkMetadata()
{
var information = new UserSpecifiedProgramInformation(2222u);
Assert.True(information.AddArtwork(null));
Assert.False(information.AddArtwork(null));
Assert.Equal(new string[] { null }, information.Artwork);
}
public void UserProgramInformation_AddVersionMetadata_AddsVersionMetadata()
{
var information = new UserSpecifiedProgramInformation(2222u);
Assert.True(information.AddVersion(null));
Assert.False(information.AddVersion(null));
Assert.Equal(new string[] { null }, information.Versions);
}
public void UserProgramInformation_AddBuildDateMetadata_AddsBuildDateMetadata()
{
var information = new UserSpecifiedProgramInformation(2222u);
Assert.True(information.AddBuildDate(MetadataDateTime.MinValue));
Assert.False(information.AddBuildDate(MetadataDateTime.MinValue));
Assert.Equal(new[] { MetadataDateTime.MinValue }, information.BuildDates);
}
public void UserProgramInformation_AddSoundEffectsMetadata_AddsSoundEffectsMetadata()
{
var information = new UserSpecifiedProgramInformation(2222u);
Assert.True(information.AddSoundEffects(null));
Assert.False(information.AddSoundEffects(null));
Assert.Equal(new string[] { null }, information.SoundEffects);
}
public void UserProgramInformation_AddShortNameMetadata_AddsShortNameMetadata()
{
var information = new UserSpecifiedProgramInformation(2222u);
Assert.True(information.AddShortName(null));
Assert.False(information.AddShortName(null));
Assert.Equal(new string[] { null }, information.ShortNames);
}
public void UserSpecifiedProgramInformation_ConstructWithEmptyNonMetadataProgramInformation_CreatesExpectedInformation()
{
var sourceInformation = new TestProgramInformation();
var information = new UserSpecifiedProgramInformation(sourceInformation);
Assert.False(information.IsModified);
VerifyInformation(sourceInformation, information);
}
public void UserProgramInformation_SetFeatures_BehavesCorrectly(IProgramFeatures initialFeatures, IProgramFeatures newProgramFeatures, IProgramFeatures expectedProgramFeatures, bool expectedIsModified)
{
var information = new UserSpecifiedProgramInformation(4, "hey", "1997", (ProgramFeatures)initialFeatures);
Assert.False(information.IsModified);
information.Features = (ProgramFeatures)newProgramFeatures;
Assert.Equal(expectedProgramFeatures, information.Features);
Assert.Equal(expectedIsModified, information.IsModified);
}
public void UserProgramInformation_SetFeaturesToUnrecognizedFeatures_DoesNotModifyInformation()
{
var information = new UserSpecifiedProgramInformation(8);
Assert.False(information.IsModified);
information.Features = ProgramFeatures.GetUnrecognizedRomFeatures();
Assert.Equal(ProgramFeatures.GetUnrecognizedRomFeatures(), information.Features);
Assert.False(information.IsModified);
}
public void UserProgramInformation_AddAdditionalInformationMetadata_AddsAdditionalInformationMetadata()
{
var information = new UserSpecifiedProgramInformation(2222u);
information.AddAdditionalInformation(string.Empty, "first");
information.AddAdditionalInformation(string.Empty, "second");
information.AddAdditionalInformation("derp", "other");
var expectedAdditionalInformation = new[] { ": first, second", "derp: other" };
Assert.Equal(expectedAdditionalInformation, information.AdditionalInformation);
}
public void UserSpecifiedProgramInformationTable_AddDatabaseEntry_AddsEntry()
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/add_entry_to_database.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 0);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var entry = new UserSpecifiedProgramInformation(0x98765432, "My dev ROM");
Assert.True(database.AddEntry(entry));
}
public void UserProgramInformation_AddCrc_AddsCrc()
{
var information = new UserSpecifiedProgramInformation(2u);
var expectedCrcs = information.Crcs.ToList();
var newCrcData = new CrcData(3u, "Busted", IncompatibilityFlags.LtoFlash);
information.AddCrc(newCrcData.Crc, newCrcData.Description, newCrcData.Incompatibilities);
expectedCrcs.Add(newCrcData);
Assert.Equal(expectedCrcs, information.Crcs);
}
public void UserSpecifiedProgramInformationTable_GroupWithExistingEntryWithNewEntryAndNullExistingEntry_ReturnsFalse()
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/group_new_entry_null_existing.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 1);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var newEntry = new UserSpecifiedProgramInformation(0x23457689, "My new dev ROM");
Assert.False(database.GroupWithExistingEntry(newEntry, null));
}
public void UserSpecifiedProgramInformationTable_GroupWithExistingEntryWithNullNewEntry_ThrowsNullReferenceException()
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/group_null_new_entry.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 3);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var entry = new UserSpecifiedProgramInformation(0x23457689, "My dev ROM");
Assert.True(database.AddEntry(entry));
Assert.Throws <NullReferenceException>(() => database.GroupWithExistingEntry(null, entry));
}
public void UserSpecifiedProgramInformationTable_AddDuplicateDatabaseEntry_DoesNotAddEntry()
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/add_duplicate_entry_to_database.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 8);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var entry = new UserSpecifiedProgramInformation(0x23457689, "My dev ROM");
Assert.True(database.AddEntry(entry));
entry = new UserSpecifiedProgramInformation(0x23457689, "My other dev ROM");
Assert.False(database.AddEntry(entry));
}
public void UserSpecifiedProgramInformationTable_GroupWithExistingEntryWithNoMatchingEntry_DoesNotGroupEntry()
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/group_nonexisting_entry_does_not_group.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 9);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var entry = new UserSpecifiedProgramInformation(0x98765432, "My dev ROM");
Assert.True(database.AddEntry(entry));
var newEntry = new UserSpecifiedProgramInformation(0x23457689, "My other dev ROM");
Assert.False(database.GroupWithExistingEntry(entry, newEntry));
}
public void UserProgramInformation_SetVendor_BehavesCorrectly(string initialVendor, string newVendor)
{
var initialInformation = new TestProgramInformation()
{
Vendor = initialVendor
};
var information = new UserSpecifiedProgramInformation(initialInformation);
Assert.False(information.IsModified);
information.Vendor = newVendor;
var expectedVendor = newVendor;
Assert.Equal(expectedVendor, information.Vendor);
var expectedIsModified = initialVendor != newVendor;
Assert.Equal(expectedIsModified, information.IsModified);
}
public void UserProgramInformation_SetShortName_BehavesCorrectly(string initialShortName, string newShortName)
{
var initialInformation = new TestProgramInformation()
{
ShortName = initialShortName
};
var information = new UserSpecifiedProgramInformation(initialInformation);
Assert.False(information.IsModified);
information.ShortName = newShortName;
var expectedShortName = newShortName;
Assert.Equal(expectedShortName, information.ShortName);
var expectedIsModified = initialShortName != newShortName;
Assert.Equal(expectedIsModified, information.IsModified);
}
public void UserSpecifiedProgramInformationTable_GroupWithExistingEntry_GroupsEntries()
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/group_existing_groups.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 87);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var entry = new UserSpecifiedProgramInformation(0x23457689, "My dev ROM");
Assert.True(database.AddEntry(entry));
var newEntry = new UserSpecifiedProgramInformation(0x98765432, "My other dev ROM");
Assert.True(database.GroupWithExistingEntry(newEntry, entry));
var expectedCrcs = new[] { 0x23457689u, 0x98765432u };
Assert.Equal(expectedCrcs, entry.Crcs.Select(c => c.Crc));
}
public void UserSpecifiedProgramInformation_ConstructWithNonMetadataProgramInformation_CreatesExpectedInformation(string year)
{
var sourceInformation = new TestProgramInformation(0x24680246, null, IncompatibilityFlags.KeyboardComponent)
{
Title = "Sumpin' Mysterious",
Vendor = "Somewhat Mysterious, Inc.",
Year = year,
ShortName = "S.M.",
Features = new ProgramFeaturesBuilder().WithEcsFeatures(EcsFeatures.Synthesizer).Build() as ProgramFeatures
};
sourceInformation.AddCrc(0x13579135, "(revised)", IncompatibilityFlags.Tutorvision);
sourceInformation.SetOrigin(ProgramInformationOrigin.UpdateFragment);
var information = new UserSpecifiedProgramInformation(sourceInformation);
Assert.False(information.IsModified);
VerifyInformation(sourceInformation, information);
}
public void UserSpecifiedProgramInformation_SetTitle_SetsExpectedValue(string initialTitle, string newTitle, string expectedTitle, bool expectedIsModified)
{
// USPI behaves weirdly! If you pass null directly to constructor, it will assign "Unknown" -- and prevents empty / null.
// But, if you send IProgramInformation, it preserves whatever was in there -- even null
// SETTING is super odd.
// 1. Disallows any null/empty -- fine
// 2. Set is only allowed IF
// a) backing field is null/empty
// b) title == unknown AND new value is unknown
// THUS: if you create USPI w/ name "FOO" then YOU CANNOT RENAME IT?
// See: https://github.com/intvsteve/VINTage/issues/242
var information = new UserSpecifiedProgramInformation(2u, initialTitle);
Assert.False(information.IsModified);
information.Title = newTitle;
Assert.Equal(expectedTitle, information.Title);
Assert.Equal(expectedIsModified, information.IsModified);
}
public void UserProgramInformation_SetYear_BehavesCorrectly(string initialYear, string newYear)
{
var initialInformation = new TestProgramInformationMetadata()
{
Year = initialYear
};
initialInformation.SetAllMetadata();
var information = new UserSpecifiedProgramInformation(initialInformation);
Assert.False(information.IsModified);
information.Year = newYear;
var expectedYear = newYear;
Assert.Equal(expectedYear, information.Year);
var expectedIsModified = initialYear != newYear;
Assert.Equal(expectedIsModified, information.IsModified);
}
public void UserSpecifiedProgramInformationTable_FindProgramWithProgramIdentifier_FindsProgramAsExpected(uint crc, bool expectedFound)
{
IReadOnlyList <string> romPaths;
var storageAccess = UserSpecifiedProgramInformationTableTestsStorageAccess.Initialize(out romPaths, null);
var databaseFilePath = "/testing/database/find_by_program_info.xml";
storageAccess.AddDatabaseFile(databaseFilePath, 4);
var database = UserSpecifiedProgramInformationTable.Initialize(databaseFilePath) as UserSpecifiedProgramInformationTable;
var entry = new UserSpecifiedProgramInformation(0x98765432u, "My findable ROM");
database.AddEntry(entry);
var foundInfo = database.FindProgram(new ProgramIdentifier(crc, 0));
if (expectedFound)
{
Assert.True(object.ReferenceEquals(entry, foundInfo));
}
else
{
Assert.Null(foundInfo);
}
}
private void VerifyInformation(IProgramInformation expectedInformation, UserSpecifiedProgramInformation information)
{
var expectedTitle = string.IsNullOrEmpty(expectedInformation.Title) ? ProgramInformation.UnknownProgramTitle : expectedInformation.Title;
Assert.Equal(expectedInformation.DataOrigin, information.DataOrigin);
Assert.Equal(expectedInformation.Title, information.Title);
Assert.Equal(expectedInformation.Vendor, information.Vendor);
MetadataDateTime dontCare;
Assert.Equal(GetExpectedYearString(expectedInformation.Year, out dontCare), information.Year);
Assert.Equal(expectedInformation.Features, information.Features);
var expectedShortName = expectedInformation.ShortName;
if (string.IsNullOrEmpty(expectedShortName))
{
var metadata = expectedInformation as IProgramMetadata;
if ((metadata != null) && (metadata.ShortNames != null) && !string.IsNullOrEmpty(metadata.ShortNames.FirstOrDefault()))
{
expectedShortName = metadata.ShortNames.FirstOrDefault();
}
}
Assert.Equal(expectedShortName, information.ShortName);
Assert.Equal(expectedInformation.Crcs.Count(), information.Crcs.Count());
foreach (var crcDataPair in expectedInformation.Crcs.Zip(information.Crcs, (e, a) => new KeyValuePair <CrcData, CrcData>(e, a)))
{
// TODO: Determine why the BinConfigTemplate is not propagated.
Assert.Equal(crcDataPair.Key.Crc, crcDataPair.Value.Crc);
Assert.Equal(crcDataPair.Key.Description, crcDataPair.Value.Description);
Assert.Equal(crcDataPair.Key.Incompatibilities, crcDataPair.Value.Incompatibilities);
Assert.Equal(crcDataPair.Key.BinConfigTemplate, crcDataPair.Value.BinConfigTemplate);
}
VerifyMetadata(expectedInformation, information);
}
public void UserProgramInformation_AddNullAdditionalInformationMetadata_ThrowsArgumentNullException()
{
var information = new UserSpecifiedProgramInformation(2222u);
Assert.Throws <ArgumentNullException>(() => information.AddAdditionalInformation(null, null));
}
