public void MetadataHelpers_DeserializeBufferContainingDateTimeWithOutOfRangeOffsetMinutes_ProducesExpectedMetadataDateTime()
{
var year = 2018;
var month = 5;
var day = 4;
var hour = 3;
var minute = 2;
var second = 1;
var offsetHours = 0;
var offsetMinutes = 88;
uint payloadLength;
var parsedMetadataDateTime = MetadataDateTime.MinValue;
using (var reader = new BinaryReader(InitializeMetadataDateTimeBuffer(out payloadLength, year, month, day, hour, minute, second, offsetHours, offsetMinutes)))
{
parsedMetadataDateTime = reader.ParseDateTimeFromMetadata(payloadLength);
}
// NOTE: The builder allows specifying offset entirely in minutes, whereas the above parser operates on bytes.
// As a result, the above produces a timestamp with UtcOffset flag specified, and it just ignores the minutes setting.
// This is correct behavior, but subtly different than the results from using the Builder. Therefore, alter the minutes offset
// passed to the builder to create the expected result.
offsetMinutes = 0;
var expectedMetadataDateTime = new MetadataDateTimeBuilder(year).WithMonth(month).WithDay(day).WithHour(hour).WithMinute(minute).WithSecond(second).WithOffset(offsetHours, offsetMinutes).Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(parsedMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
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 MetadataHelpers_DeserializeBufferContainingDateTimeWithOutOfRangeOffsetHours_ProducesExpectedMetadataDateTime()
{
var year = 2018;
var month = 6;
var day = 5;
var hour = 4;
var minute = 3;
var second = 2;
var offsetHours = 16;
uint payloadLength;
var parsedMetadataDateTime = MetadataDateTime.MinValue;
using (var reader = new BinaryReader(InitializeMetadataDateTimeBuffer(out payloadLength, year, month, day, hour, minute, second, offsetHours)))
{
parsedMetadataDateTime = reader.ParseDateTimeFromMetadata(payloadLength);
}
// Note that we don't bother with sending the offset data to the builder here. This is because of subtle differences with how the builder
// processes offset vs. how the parser does. In this test, the parser stops after the offset hours check. The Builder takes offset as hours
// and minutes, and would ignore the hours, but honor the minutes. So just skip defining offset at all with the builder.
var expectedMetadataDateTime = new MetadataDateTimeBuilder(year).WithMonth(month).WithDay(day).WithHour(hour).WithMinute(minute).WithSecond(second).Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(parsedMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
private string GetExpectedYearString(string year, out MetadataDateTime date)
{
date = MetadataDateTime.MinValue;
var yearString = year;
if (!string.IsNullOrEmpty(year))
{
int releaseYear;
if (int.TryParse(year, out releaseYear))
{
try
{
var dateBuilder = new MetadataDateTimeBuilder(releaseYear);
date = dateBuilder.Build();
}
catch (ArgumentOutOfRangeException)
{
yearString = string.Empty;
}
}
else
{
}
}
return(yearString);
}
public void MetadataDateTimeBuilder_WithLeapSecond_CreatesExpectedMetadataDateTime()
{
var year = 1999;
var second = 60;
var flags = MetadataDateTimeFlags.Year | MetadataDateTimeFlags.Second | MetadataDateTimeFlags.LeapSecond;
var date = new System.DateTimeOffset(year, 1, 1, 0, 0, 59, TimeSpan.Zero);
var expectedMetadataDateTime = new MetadataDateTime(date, flags);
var builder = new MetadataDateTimeBuilder(year).WithSecond(second);
var actualMetadataDateTime = builder.Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(actualMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
public void SetAllMetadata()
{
var dateTimeBuilder = new MetadataDateTimeBuilder(1999);
AddReleaseDate(dateTimeBuilder.WithMonth(1).WithDay(2).Build());
AddReleaseDate(dateTimeBuilder.WithDay(3).Build());
AddBuildDate(dateTimeBuilder.WithDay(1).Build());
AddBuildDate(dateTimeBuilder.WithDay(2).Build());
foreach (var fieldId in TestProgramInformationMetadata.StringFieldIds)
{
var stringValue = fieldId.ToString();
AddMetadataValue(fieldId, stringValue);
}
}
public void MetadataDateTimeBuilder_WithUtcOffsetHoursOutOfRange_CreatesExpectedMetadataDateTime()
{
var year = 1991;
var offsetHours = 123;
var offsetMinutes = 22;
var flags = MetadataDateTimeFlags.Year;
var dateTime = new DateTime(year, 1, 1);
var date = new System.DateTimeOffset(dateTime, TimeSpan.Zero);
var expectedMetadataDateTime = new MetadataDateTime(date, flags);
var builder = new MetadataDateTimeBuilder(year).WithOffset(offsetHours, offsetMinutes);
var actualMetadataDateTime = builder.Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(actualMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
public void MetadataDateTimeBuilder_WithLocalUtcOffset_CreatesExpectedMetadataDateTime()
{
var year = 1984;
var offsetHours = -3;
var offsetMinutes = -3;
var flags = MetadataDateTimeFlags.Year | MetadataDateTimeFlags.UtcOffset;
var dateTime = new DateTime(year, 1, 1);
var offset = TimeZoneInfo.Local.GetUtcOffset(dateTime);
var date = new System.DateTimeOffset(dateTime, offset);
var expectedMetadataDateTime = new MetadataDateTime(date, flags);
var builder = new MetadataDateTimeBuilder(year).WithOffset(offsetHours, offsetMinutes).WithLocalUtcOffset();
var actualMetadataDateTime = builder.Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(actualMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
public void MetadataHelpers_DeserializeBufferContainingDateTimeWithOutOfRangeMonth_ProducesExpectedMetadataDateTime()
{
var year = 2018;
var month = 16;
uint payloadLength;
var parsedMetadataDateTime = MetadataDateTime.MinValue;
using (var reader = new BinaryReader(InitializeMetadataDateTimeBuffer(out payloadLength, year, month)))
{
parsedMetadataDateTime = reader.ParseDateTimeFromMetadata(payloadLength);
}
var expectedMetadataDateTime = new MetadataDateTimeBuilder(year).WithMonth(month).Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(parsedMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
public void MetadataDateTimeBuilder_WithInvalidValues_CreatesExpectedMetadataDateTime()
{
var year = 1979;
var month = 69;
var day = 32;
var hour = 44;
var minute = 88;
var second = -2;
var flags = MetadataDateTimeFlags.Year;
var dateTime = new DateTime(year, 1, 1);
var date = new System.DateTimeOffset(dateTime, TimeSpan.Zero);
var expectedMetadataDateTime = new MetadataDateTime(date, flags);
var builder = new MetadataDateTimeBuilder(year).WithMonth(month).WithDay(day).WithHour(hour).WithMinute(minute).WithSecond(second);
var actualMetadataDateTime = builder.Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(actualMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
public void MetadataHelpers_DeserializeBufferContainingDateTimeWithOutOfRangeMinuteAndSecond_ProducesExpectedMetadataDateTime()
{
var year = 2018;
var month = 8;
var day = 7;
var hour = 6;
var minute = 99;
var second = 120;
uint payloadLength;
var parsedMetadataDateTime = MetadataDateTime.MinValue;
using (var reader = new BinaryReader(InitializeMetadataDateTimeBuffer(out payloadLength, year, month, day, hour, minute, second)))
{
parsedMetadataDateTime = reader.ParseDateTimeFromMetadata(payloadLength);
}
var expectedMetadataDateTime = new MetadataDateTimeBuilder(year).WithMonth(month).WithDay(day).WithHour(hour).WithMinute(minute).WithSecond(second).Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(parsedMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
public void MetadataDateTimeBuilder_WithAllValidValues_CreatesExpectedMetadataDateTime()
{
var year = 2018;
var month = 10;
var day = 15;
var hour = 17;
var minute = 34;
var second = 48;
var offsetHours = 1;
var offsetMinutes = 23;
var flags = Enum.GetValues(typeof(MetadataDateTimeFlags)).Cast <MetadataDateTimeFlags>().Aggregate((all, flag) => all | flag) & ~MetadataDateTimeFlags.LeapSecond;
var offset = new TimeSpan(offsetHours, offsetMinutes, 0);
var date = new System.DateTimeOffset(year, month, day, hour, minute, second, offset);
var expectedMetadataDateTime = new MetadataDateTime(date, flags);
var builder = new MetadataDateTimeBuilder(year);
builder.WithMonth(month).WithDay(day).WithHour(hour).WithMinute(minute).WithSecond(second).WithOffset(offsetHours, offsetMinutes);
var actualMetadataDateTime = builder.Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(actualMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
public void MetadataHelpers_DeserializeBufferContainingCompleteDateTimeWithOffsetAndAdditionalPayload_ProducesExpectedMetadataDateTime()
{
var year = 2018;
var month = 10;
var day = 9;
var hour = 8;
var minute = 7;
var second = 6;
var offsetHours = 5;
var offsetMinutes = 4;
uint payloadLength;
var parsedMetadataDateTime = MetadataDateTime.MinValue;
using (var reader = new BinaryReader(InitializeMetadataDateTimeBuffer(out payloadLength, year, month, day, hour, minute, second, offsetHours, offsetMinutes, 12)))
{
parsedMetadataDateTime = reader.ParseDateTimeFromMetadata(payloadLength);
}
var expectedMetadataDateTime = new MetadataDateTimeBuilder(year).WithMonth(month).WithDay(day).WithHour(hour).WithMinute(minute).WithSecond(second).WithOffset(offsetHours, offsetMinutes).Build();
Assert.Equal(0, expectedMetadataDateTime.CompareTo(parsedMetadataDateTime, strict: true, compareOnlyCommonValidFields: false));
}
private void FinishInitialization()
{
var metadata = SourceInformation as IProgramMetadata;
if (metadata != null)
{
_longNames = new HashSet <string>(metadata.LongNames, StringComparer.OrdinalIgnoreCase);
_shortNames = new HashSet <string>(metadata.ShortNames, StringComparer.OrdinalIgnoreCase);
_descriptions = new HashSet <string>(metadata.Descriptions, StringComparer.OrdinalIgnoreCase);
_publishers = new HashSet <string>(metadata.Publishers, StringComparer.OrdinalIgnoreCase);
_programmers = new HashSet <string>(metadata.Programmers, StringComparer.OrdinalIgnoreCase);
_designers = new HashSet <string>(metadata.Designers, StringComparer.OrdinalIgnoreCase);
_graphics = new HashSet <string>(metadata.Graphics, StringComparer.OrdinalIgnoreCase);
_music = new HashSet <string>(metadata.Music, StringComparer.OrdinalIgnoreCase);
_soundEffects = new HashSet <string>(metadata.SoundEffects, StringComparer.OrdinalIgnoreCase);
_voices = new HashSet <string>(metadata.Voices, StringComparer.OrdinalIgnoreCase);
_documentation = new HashSet <string>(metadata.Documentation, StringComparer.OrdinalIgnoreCase);
_artwork = new HashSet <string>(metadata.Artwork, StringComparer.OrdinalIgnoreCase);
_releaseDates = new SortedSet <MetadataDateTime>(metadata.ReleaseDates);
_licenses = new HashSet <string>(metadata.Licenses, StringComparer.OrdinalIgnoreCase);
_contactInformation = new HashSet <string>(metadata.ContactInformation, StringComparer.OrdinalIgnoreCase);
_versions = new HashSet <string>(metadata.Versions, StringComparer.OrdinalIgnoreCase);
_buildDates = new SortedSet <MetadataDateTime>(metadata.BuildDates);
_additionalInformation = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (metadata.AdditionalInformation == null)
{
throw new ArgumentNullException("metadata.AdditionalInformation");
}
var additionalInformationIndex = 0;
foreach (var additionalInformation in metadata.AdditionalInformation)
{
_additionalInformation[additionalInformationIndex.ToString(CultureInfo.InvariantCulture)] = additionalInformation;
++additionalInformationIndex;
}
if (string.IsNullOrEmpty(_shortName))
{
if (!string.IsNullOrEmpty(_shortNames.FirstOrDefault()))
{
_shortName = _shortNames.First();
}
}
}
else
{
_longNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_shortNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_descriptions = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_publishers = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_programmers = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_designers = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_graphics = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_music = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_soundEffects = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_voices = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_documentation = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_artwork = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_releaseDates = new SortedSet <MetadataDateTime>();
_licenses = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_contactInformation = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_versions = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_buildDates = new SortedSet <MetadataDateTime>();
_additionalInformation = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (!string.IsNullOrEmpty(_title))
{
_longNames.Add(_title);
}
if (!string.IsNullOrEmpty(_shortName))
{
_shortNames.Add(_shortName);
}
if (!string.IsNullOrEmpty(_vendor))
{
AddPublisher(_vendor);
}
if (!string.IsNullOrEmpty(_year))
{
int releaseYear;
if (int.TryParse(_year, out releaseYear))
{
try
{
var dateBuilder = new MetadataDateTimeBuilder(releaseYear);
var releaseDate = dateBuilder.Build();
AddReleaseDate(releaseDate);
}
catch (ArgumentOutOfRangeException)
{
// Scrambled LUIGI files may return a year string of "-1" via the intvname tool.
_year = string.Empty;
}
}
}
}
_initialized = true;
}
public void MetadataDateTimeBuilder_WithYearOutOfRange_ThrowsArgumentOutOfRangeException(int year)
{
var builder = new MetadataDateTimeBuilder(year);
Assert.Throws <ArgumentOutOfRangeException>(() => builder.Build());
}
private void VerifyExpectedMetadata(IProgramMetadata metadata)
{
var expectedLongNames = new[] { "Tag-A-Long Todd" };
Assert.Empty(expectedLongNames.Except(metadata.LongNames, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.LongNames.Except(expectedLongNames, StringComparer.OrdinalIgnoreCase));
var expectedShortNames = new[] { "Tod" };
Assert.Empty(expectedShortNames.Except(metadata.ShortNames, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.ShortNames.Except(expectedShortNames, StringComparer.OrdinalIgnoreCase));
var expectedDescriptions = new[] { "Desc 3", "desc iv", string.Empty, "Description the first.", "Description the Second" };
Assert.Empty(expectedDescriptions.Except(metadata.Descriptions, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Descriptions.Except(expectedDescriptions, StringComparer.OrdinalIgnoreCase));
var expectedPublishers = new[] { "Zbiciak Electronics", "Left Turn Only" };
Assert.Empty(expectedPublishers.Except(metadata.Publishers, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Publishers.Except(expectedPublishers, StringComparer.OrdinalIgnoreCase));
var expectedProgrammers = new[] { "Joe Zbiciak", "intvnut", "JRMZ" };
Assert.Empty(expectedProgrammers.Except(metadata.Programmers, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Programmers.Except(expectedProgrammers, StringComparer.OrdinalIgnoreCase));
var expectedDesigners = new[] { "Unsure", "Unsurely - don't call me surely." };
Assert.Empty(expectedDesigners.Except(metadata.Designers, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Designers.Except(expectedDesigners, StringComparer.OrdinalIgnoreCase));
var expectedGraphics = new[] { "JZ", "No, not that JZ" };
Assert.Empty(expectedGraphics.Except(metadata.Graphics, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Graphics.Except(expectedGraphics, StringComparer.OrdinalIgnoreCase));
var expectedMusic = new[] { "Joe", "Wait, there's music?" };
Assert.Empty(expectedMusic.Except(metadata.Music, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Music.Except(expectedMusic, StringComparer.OrdinalIgnoreCase));
var expectedSoundEffects = new[] { "Joe Zbiciak", "Joseph Zbiciak" };
Assert.Empty(expectedSoundEffects.Except(metadata.SoundEffects, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.SoundEffects.Except(expectedSoundEffects, StringComparer.OrdinalIgnoreCase));
var expectedVoices = new[] { "None", "Really, none" };
Assert.Empty(expectedVoices.Except(metadata.Voices, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Voices.Except(expectedVoices, StringComparer.OrdinalIgnoreCase));
var expectedDocumentation = new[] { "JZ", "IM14U2C" };
Assert.Empty(expectedDocumentation.Except(metadata.Documentation, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Documentation.Except(expectedDocumentation, StringComparer.OrdinalIgnoreCase));
var expectedArtwork = new[] { "N/A", "Boxless ... for now" };
Assert.Empty(expectedArtwork.Except(metadata.Artwork, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Artwork.Except(expectedArtwork, StringComparer.OrdinalIgnoreCase));
var date0 = new MetadataDateTimeBuilder(1999).WithMonth(9).WithDay(9).Build();
var date1 = new MetadataDateTimeBuilder(2001).WithMonth(1).WithDay(1).Build();
var date2 = new MetadataDateTimeBuilder(1997).WithMonth(5).WithDay(17).WithHour(0).WithMinute(29).WithSecond(24).WithOffset(-7, -12).Build();
var date3 = new MetadataDateTimeBuilder(1999).WithMonth(10).WithDay(2).WithHour(5).WithMinute(16).WithSecond(18).WithOffset(7, 0).Build();
var expectedReleaseDates = new[] { date0, date1, date2, date3 };
Assert.Empty(expectedReleaseDates.Except(metadata.ReleaseDates));
Assert.Empty(metadata.ReleaseDates.Except(expectedReleaseDates));
var expectedLicenses = new[] { "PD", "Not GPL" };
Assert.Empty(expectedLicenses.Except(metadata.Licenses, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Licenses.Except(expectedLicenses, StringComparer.OrdinalIgnoreCase));
var expectedContactInformation = new[] { "spatula-city.org", "leftturnonly.info" };
Assert.Empty(expectedContactInformation.Except(metadata.ContactInformation, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.ContactInformation.Except(expectedContactInformation, StringComparer.OrdinalIgnoreCase));
// Both 'version' and 'versions' are parsed
var expectedVersions = new[] { "Tutorial", "Learning stuff", "Tutorial 2", "Learning stuff" };
Assert.Empty(expectedVersions.Except(metadata.Versions, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.Versions.Except(expectedVersions, StringComparer.OrdinalIgnoreCase));
date0 = new MetadataDateTimeBuilder(2013).WithMonth(10).WithDay(31).WithHour(17).WithMinute(57).WithSecond(4).WithOffset(-7, 0).Build();
date1 = new MetadataDateTimeBuilder(2013).WithMonth(10).WithDay(31).WithHour(17).WithMinute(57).WithSecond(4).WithOffset(0, -18).Build();
date2 = new MetadataDateTimeBuilder(2013).WithMonth(10).WithDay(31).WithHour(17).WithMinute(57).WithSecond(60).WithOffset(7, 42).Build();
date3 = new MetadataDateTimeBuilder(2013).WithMonth(10).WithDay(31).WithHour(17).WithMinute(57).WithSecond(60).WithOffset(0, 55).Build();
var expectedBuildDates = new[] { date0, date1, date2, date3 };
Assert.Empty(metadata.BuildDates.Except(expectedBuildDates));
Assert.Empty(expectedBuildDates.Except(metadata.BuildDates));
var expectedAdditionalInformation = Enumerable.Empty <string>();
Assert.Empty(expectedAdditionalInformation.Except(metadata.AdditionalInformation, StringComparer.OrdinalIgnoreCase));
Assert.Empty(metadata.AdditionalInformation.Except(expectedAdditionalInformation, StringComparer.OrdinalIgnoreCase));
}
private static IEnumerable <Tuple <IProgramMetadata, XmlRomInformationDatabaseColumnName, string> > GetTestMetadataForColumn(XmlRomInformationDatabaseColumnName column, int numValues)
{
var strings = Enumerable.Repeat(string.Empty, 1);
var suffixes = Enumerable.Range(0, numValues);
var htmlEncode = true;
var includeFirstOnly = false;
string expectedString = null;
for (int i = 0; i < 2; ++i)
{
var programMetadataBuilder = new ProgramMetadataBuilder();
expectedString = null;
switch (column)
{
case XmlRomInformationDatabaseColumnName.title:
programMetadataBuilder.WithLongNames(strings);
includeFirstOnly = true;
break;
case XmlRomInformationDatabaseColumnName.short_name:
programMetadataBuilder.WithShortNames(strings);
includeFirstOnly = true;
break;
case XmlRomInformationDatabaseColumnName.vendor:
programMetadataBuilder.WithPublishers(strings);
includeFirstOnly = true;
break;
case XmlRomInformationDatabaseColumnName.description:
programMetadataBuilder.WithDescriptions(strings);
includeFirstOnly = true;
break;
case XmlRomInformationDatabaseColumnName.release_date:
if (i == 0)
{
var date = new MetadataDateTimeBuilder(1981).WithMonth(12).WithDay(25).Build();
programMetadataBuilder.WithReleaseDates(new[] { date });
expectedString = "1981-12-25";
}
else
{
var dates = suffixes.Select(d => new MetadataDateTimeBuilder(1982).WithMonth(8).WithDay(d + 1).Build());
programMetadataBuilder.WithReleaseDates(dates);
expectedString = "1982-08-01";
}
includeFirstOnly = true;
break;
case XmlRomInformationDatabaseColumnName.program:
programMetadataBuilder.WithProgrammers(strings);
break;
case XmlRomInformationDatabaseColumnName.concept:
programMetadataBuilder.WithDesigners(strings);
break;
case XmlRomInformationDatabaseColumnName.game_graphics:
programMetadataBuilder.WithGraphics(strings);
break;
case XmlRomInformationDatabaseColumnName.soundfx:
programMetadataBuilder.WithSoundEffects(strings);
break;
case XmlRomInformationDatabaseColumnName.music:
programMetadataBuilder.WithMusic(strings);
break;
case XmlRomInformationDatabaseColumnName.voices:
programMetadataBuilder.WithVoices(strings);
break;
case XmlRomInformationDatabaseColumnName.game_docs:
programMetadataBuilder.WithDocumentation(strings);
break;
case XmlRomInformationDatabaseColumnName.box_art:
programMetadataBuilder.WithArtwork(strings);
break;
case XmlRomInformationDatabaseColumnName.name:
programMetadataBuilder.WithVersions(strings);
includeFirstOnly = true;
break;
case XmlRomInformationDatabaseColumnName.build_date:
if (i == 0)
{
var date = new MetadataDateTimeBuilder(1980).WithMonth(8).WithDay(4).Build();
programMetadataBuilder.WithBuildDates(new[] { date });
expectedString = "1980-08-04";
}
else
{
var dates = suffixes.Select(d => new MetadataDateTimeBuilder(1984).WithMonth(6).WithDay(d + 12).Build());
programMetadataBuilder.WithBuildDates(dates);
expectedString = "1984-06-12";
}
includeFirstOnly = true;
break;
case XmlRomInformationDatabaseColumnName.other:
programMetadataBuilder.WithAdditionalInformation(strings);
break;
case XmlRomInformationDatabaseColumnName.license:
programMetadataBuilder.WithLicenses(strings);
break;
case XmlRomInformationDatabaseColumnName.contact_info:
programMetadataBuilder.WithContactInformation(strings);
htmlEncode = false;
break;
default:
throw new InvalidOperationException();
}
if (string.IsNullOrEmpty(expectedString))
{
if (includeFirstOnly)
{
strings = new[] { strings.First() };
}
if (htmlEncode)
{
expectedString = string.Join("|", strings.Select(s => HtmlEncode(s)));
}
else
{
expectedString = string.Join("|", strings);
}
}
yield return(new Tuple <IProgramMetadata, XmlRomInformationDatabaseColumnName, string>(programMetadataBuilder.Build(), column, expectedString));
strings = suffixes.Select(s => "Abbott & Costello Part " + s.ToString(CultureInfo.InvariantCulture));
}
yield return(new Tuple <IProgramMetadata, XmlRomInformationDatabaseColumnName, string>(new ProgramMetadata(), column, includeFirstOnly ? null : string.Empty));
}
