mirror of
https://github.com/claunia/SabreTools.git
synced 2025-12-16 19:14:27 +00:00
894 lines
35 KiB
C#
894 lines
35 KiB
C#
using System;
|
|
using SabreTools.Core;
|
|
using Xunit;
|
|
|
|
namespace SabreTools.Test.Parser
|
|
{
|
|
/// <remarks>
|
|
/// Filenames that end in `-files` are real examples.
|
|
/// All other files are artificial and may not fully represent real examples.
|
|
/// </remarks>
|
|
public class DeserializationTests
|
|
{
|
|
[Theory]
|
|
[InlineData("test-archivedotorg-files.xml", 22)]
|
|
public void ArchiveDotOrgDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.ArchiveDotOrg.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.File);
|
|
Assert.Equal(count, dat.File.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Null(dat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dat.ADDITIONAL_ELEMENTS);
|
|
foreach (var file in dat.File)
|
|
{
|
|
Assert.Null(file.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(file.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-attractmode-files.txt", 11)]
|
|
public void AttractModeDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.AttractMode.Deserialize(filename);
|
|
|
|
// Validate texpected: he values
|
|
Assert.NotNull(dat?.Row);
|
|
Assert.Equal(count, dat.Row.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
foreach (var file in dat.Row)
|
|
{
|
|
Assert.Null(file.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-cmp-files.dat", 59)]
|
|
public void ClrMameProDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.ClrMamePro.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.ClrMamePro);
|
|
Assert.Equal(count, dat.Game.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Empty(dat.ADDITIONAL_ELEMENTS);
|
|
Assert.Null(dat.ClrMamePro.ADDITIONAL_ELEMENTS);
|
|
foreach (var game in dat.Game)
|
|
{
|
|
Assert.Empty(game.ADDITIONAL_ELEMENTS);
|
|
foreach (var item in game.Item)
|
|
{
|
|
switch (item)
|
|
{
|
|
case Models.ClrMamePro.Release release:
|
|
Assert.Empty(release.ADDITIONAL_ELEMENTS);
|
|
break;
|
|
case Models.ClrMamePro.BiosSet biosset:
|
|
Assert.Empty(biosset.ADDITIONAL_ELEMENTS);
|
|
break;
|
|
case Models.ClrMamePro.Rom rom:
|
|
Assert.Empty(rom.ADDITIONAL_ELEMENTS);
|
|
break;
|
|
case Models.ClrMamePro.Disk disk:
|
|
Assert.Empty(disk.ADDITIONAL_ELEMENTS);
|
|
break;
|
|
case Models.ClrMamePro.Media media:
|
|
Assert.Empty(media.ADDITIONAL_ELEMENTS);
|
|
break;
|
|
case Models.ClrMamePro.Sample sample:
|
|
Assert.Empty(sample.ADDITIONAL_ELEMENTS);
|
|
break;
|
|
case Models.ClrMamePro.Archive archive:
|
|
Assert.Empty(archive.ADDITIONAL_ELEMENTS);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-doscenter-files.dat.gz", 34965)]
|
|
public void DosCenterDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.DosCenter.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.DosCenter);
|
|
Assert.Equal(count, dat.Game.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Empty(dat.ADDITIONAL_ELEMENTS);
|
|
Assert.Empty(dat.DosCenter.ADDITIONAL_ELEMENTS);
|
|
foreach (var game in dat.Game)
|
|
{
|
|
Assert.Empty(game.ADDITIONAL_ELEMENTS);
|
|
foreach (var file in game.File)
|
|
{
|
|
Assert.Empty(file.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-smdb-files.txt", 6113)]
|
|
public void EverdriveSMDBDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.EverdriveSMDB.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.Row);
|
|
Assert.Equal(count, dat.Row.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
foreach (var file in dat.Row)
|
|
{
|
|
Assert.Null(file.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-sfv-files.sfv", Hash.CRC, 100)]
|
|
[InlineData("test-md5-files.md5", Hash.MD5, 100)]
|
|
[InlineData("test-sha1-files.sha1", Hash.SHA1, 100)]
|
|
[InlineData("test-sha256.sha256", Hash.SHA256, 1)]
|
|
[InlineData("test-sha384.sha384", Hash.SHA384, 1)]
|
|
[InlineData("test-sha512.sha512", Hash.SHA512, 1)]
|
|
[InlineData("test-spamsum.spamsum", Hash.SpamSum, 1)]
|
|
public void HashfileDeserializeTest(string path, Hash hash, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.Hashfile.Deserialize(filename, hash);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat);
|
|
|
|
switch (hash)
|
|
{
|
|
case Hash.CRC:
|
|
Assert.Equal(count, dat.SFV.Length);
|
|
break;
|
|
case Hash.MD5:
|
|
Assert.Equal(count, dat.MD5.Length);
|
|
break;
|
|
case Hash.SHA1:
|
|
Assert.Equal(count, dat.SHA1.Length);
|
|
break;
|
|
case Hash.SHA256:
|
|
Assert.Equal(count, dat.SHA256.Length);
|
|
break;
|
|
case Hash.SHA384:
|
|
Assert.Equal(count, dat.SHA384.Length);
|
|
break;
|
|
case Hash.SHA512:
|
|
Assert.Equal(count, dat.SHA512.Length);
|
|
break;
|
|
case Hash.SpamSum:
|
|
Assert.Equal(count, dat.SpamSum.Length);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(nameof(hash));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-listrom-files.txt.gz", 45861)]
|
|
public void ListromDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.Listrom.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.Set);
|
|
Assert.Equal(count, dat.Set.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Empty(dat.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-listxml-files.xml.gz", 45861)]
|
|
public void ListxmlDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.Listxml.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.Machine);
|
|
Assert.Equal(count, dat.Machine.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Null(dat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dat.ADDITIONAL_ELEMENTS);
|
|
foreach (var machine in dat.Machine)
|
|
{
|
|
Assert.Null(machine.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(machine.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var biosset in machine.BiosSet ?? Array.Empty<Models.Listxml.BiosSet>())
|
|
{
|
|
Assert.Null(biosset.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(biosset.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var rom in machine.Rom ?? Array.Empty<Models.Listxml.Rom>())
|
|
{
|
|
Assert.Null(rom.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(rom.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var disk in machine.Disk ?? Array.Empty<Models.Listxml.Disk>())
|
|
{
|
|
Assert.Null(disk.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(disk.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var deviceRef in machine.DeviceRef ?? Array.Empty<Models.Listxml.DeviceRef>())
|
|
{
|
|
Assert.Null(deviceRef.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(deviceRef.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var sample in machine.Sample ?? Array.Empty<Models.Listxml.Sample>())
|
|
{
|
|
Assert.Null(sample.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(sample.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var chip in machine.Chip ?? Array.Empty<Models.Listxml.Chip>())
|
|
{
|
|
Assert.Null(chip.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(chip.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var display in machine.Display ?? Array.Empty<Models.Listxml.Display>())
|
|
{
|
|
Assert.Null(display.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(display.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (machine.Sound != null)
|
|
{
|
|
Assert.Null(machine.Sound.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(machine.Sound.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (machine.Input != null)
|
|
{
|
|
Assert.Null(machine.Input.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(machine.Input.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var control in machine.Input.Control ?? Array.Empty<Models.Listxml.Control>())
|
|
{
|
|
Assert.Null(control.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(control.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var dipswitch in machine.DipSwitch ?? Array.Empty<Models.Listxml.DipSwitch>())
|
|
{
|
|
Assert.Null(dipswitch.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dipswitch.ADDITIONAL_ELEMENTS);
|
|
|
|
if (dipswitch.Condition != null)
|
|
{
|
|
Assert.Null(dipswitch.Condition.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dipswitch.Condition.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var diplocation in dipswitch.DipLocation ?? Array.Empty<Models.Listxml.DipLocation>())
|
|
{
|
|
Assert.Null(diplocation.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(diplocation.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var dipvalue in dipswitch.DipValue ?? Array.Empty<Models.Listxml.DipValue>())
|
|
{
|
|
Assert.Null(dipvalue.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dipvalue.ADDITIONAL_ELEMENTS);
|
|
|
|
if (dipvalue.Condition != null)
|
|
{
|
|
Assert.Null(dipvalue.Condition.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dipvalue.Condition.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var configuration in machine.Configuration ?? Array.Empty<Models.Listxml.Configuration>())
|
|
{
|
|
Assert.Null(configuration.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(configuration.ADDITIONAL_ELEMENTS);
|
|
|
|
if (configuration.Condition != null)
|
|
{
|
|
Assert.Null(configuration.Condition.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(configuration.Condition.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var conflocation in configuration.ConfLocation ?? Array.Empty<Models.Listxml.ConfLocation>())
|
|
{
|
|
Assert.Null(conflocation.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(conflocation.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var confsetting in configuration.ConfSetting ?? Array.Empty<Models.Listxml.ConfSetting>())
|
|
{
|
|
Assert.Null(confsetting.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(confsetting.ADDITIONAL_ELEMENTS);
|
|
|
|
if (confsetting.Condition != null)
|
|
{
|
|
Assert.Null(confsetting.Condition.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(confsetting.Condition.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var port in machine.Port ?? Array.Empty<Models.Listxml.Port>())
|
|
{
|
|
Assert.Null(port.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(port.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var analog in port.Analog ?? Array.Empty<Models.Listxml.Analog>())
|
|
{
|
|
Assert.Null(analog.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(analog.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var adjuster in machine.Adjuster ?? Array.Empty<Models.Listxml.Adjuster>())
|
|
{
|
|
Assert.Null(adjuster.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(adjuster.ADDITIONAL_ELEMENTS);
|
|
|
|
if (adjuster.Condition != null)
|
|
{
|
|
Assert.Null(adjuster.Condition.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(adjuster.Condition.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
if (machine.Driver != null)
|
|
{
|
|
Assert.Null(machine.Driver.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(machine.Driver.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var feature in machine.Feature ?? Array.Empty<Models.Listxml.Feature>())
|
|
{
|
|
Assert.Null(feature.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(feature.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var device in machine.Device ?? Array.Empty<Models.Listxml.Device>())
|
|
{
|
|
Assert.Null(device.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(device.ADDITIONAL_ELEMENTS);
|
|
|
|
if (device.Instance != null)
|
|
{
|
|
Assert.Null(device.Instance.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(device.Instance.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var extension in device.Extension ?? Array.Empty<Models.Listxml.Extension>())
|
|
{
|
|
Assert.Null(extension.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(extension.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var slot in machine.Slot ?? Array.Empty<Models.Listxml.Slot>())
|
|
{
|
|
Assert.Null(slot.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(slot.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var slotoption in slot.SlotOption ?? Array.Empty<Models.Listxml.SlotOption>())
|
|
{
|
|
Assert.Null(slotoption.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(slotoption.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var softwarelist in machine.SoftwareList ?? Array.Empty<Models.Listxml.SoftwareList>())
|
|
{
|
|
Assert.Null(softwarelist.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(softwarelist.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var ramoption in machine.RamOption ?? Array.Empty<Models.Listxml.RamOption>())
|
|
{
|
|
Assert.Null(ramoption.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(ramoption.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-logiqx-files1.xml.gz", 45875)]
|
|
[InlineData("test-logiqx-files2.xml", 761)]
|
|
public void LogiqxDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.Logiqx.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.Game);
|
|
Assert.Equal(count, dat.Game.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Null(dat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dat.ADDITIONAL_ELEMENTS);
|
|
if (dat.Header != null)
|
|
{
|
|
var header = dat.Header;
|
|
Assert.Null(header.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(header.ADDITIONAL_ELEMENTS);
|
|
|
|
if (header.ClrMamePro != null)
|
|
{
|
|
var cmp = header.ClrMamePro;
|
|
Assert.Null(cmp.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(cmp.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (header.RomCenter != null)
|
|
{
|
|
var rc = header.RomCenter;
|
|
Assert.Null(rc.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(rc.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var game in dat.Game)
|
|
{
|
|
Assert.Null(game.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(game.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var item in game.Item ?? Array.Empty<Models.Logiqx.ItemBase>())
|
|
{
|
|
Assert.Null(item.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(item.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (game.Trurip != null)
|
|
{
|
|
var trurip = game.Trurip;
|
|
Assert.Null(trurip.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(trurip.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var dir in dat.Dir ?? Array.Empty<Models.Logiqx.Dir>())
|
|
{
|
|
foreach (var game in dir.Game)
|
|
{
|
|
Assert.Null(game.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(game.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var item in game.Item ?? Array.Empty<Models.Logiqx.ItemBase>())
|
|
{
|
|
Assert.Null(item.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(item.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (game.Trurip != null)
|
|
{
|
|
var trurip = game.Trurip;
|
|
Assert.Null(trurip.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(trurip.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-offlinelist-files.xml", 6750)]
|
|
public void OfflineListDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.OfflineList.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.Games?.Game);
|
|
Assert.Equal(count, dat.Games.Game.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Null(dat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dat.ADDITIONAL_ELEMENTS);
|
|
if (dat.Configuration != null)
|
|
{
|
|
var configuration = dat.Configuration;
|
|
Assert.Null(configuration.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(configuration.ADDITIONAL_ELEMENTS);
|
|
|
|
if (configuration.Infos != null)
|
|
{
|
|
var infos = configuration.Infos;
|
|
Assert.Null(infos.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(infos.ADDITIONAL_ELEMENTS);
|
|
|
|
if (infos.Title != null)
|
|
{
|
|
var title = infos.Title;
|
|
Assert.Null(title.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(title.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.Location != null)
|
|
{
|
|
var location = infos.Location;
|
|
Assert.Null(location.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(location.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.Publisher != null)
|
|
{
|
|
var publisher = infos.Publisher;
|
|
Assert.Null(publisher.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(publisher.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.SourceRom != null)
|
|
{
|
|
var sourceRom = infos.SourceRom;
|
|
Assert.Null(sourceRom.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(sourceRom.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.SaveType != null)
|
|
{
|
|
var saveType = infos.SaveType;
|
|
Assert.Null(saveType.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(saveType.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.RomSize != null)
|
|
{
|
|
var romSize = infos.RomSize;
|
|
Assert.Null(romSize.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(romSize.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.ReleaseNumber != null)
|
|
{
|
|
var releaseNumber = infos.ReleaseNumber;
|
|
Assert.Null(releaseNumber.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(releaseNumber.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.LanguageNumber != null)
|
|
{
|
|
var languageNumber = infos.LanguageNumber;
|
|
Assert.Null(languageNumber.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(languageNumber.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.Comment != null)
|
|
{
|
|
var comment = infos.Comment;
|
|
Assert.Null(comment.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(comment.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.RomCRC != null)
|
|
{
|
|
var romCRC = infos.RomCRC;
|
|
Assert.Null(romCRC.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(romCRC.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.Im1CRC != null)
|
|
{
|
|
var im1CRC = infos.Im1CRC;
|
|
Assert.Null(im1CRC.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(im1CRC.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.Im2CRC != null)
|
|
{
|
|
var im2CRC = infos.Im2CRC;
|
|
Assert.Null(im2CRC.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(im2CRC.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (infos.Languages != null)
|
|
{
|
|
var languages = infos.Languages;
|
|
Assert.Null(languages.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(languages.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
if (configuration.CanOpen != null)
|
|
{
|
|
var canOpen = configuration.CanOpen;
|
|
Assert.Null(canOpen.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(canOpen.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (configuration.NewDat != null)
|
|
{
|
|
var newDat = configuration.NewDat;
|
|
Assert.Null(newDat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(newDat.ADDITIONAL_ELEMENTS);
|
|
|
|
if (newDat.DatUrl != null)
|
|
{
|
|
var datURL = newDat.DatUrl;
|
|
Assert.Null(datURL.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(datURL.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
if (configuration.Search != null)
|
|
{
|
|
var search = configuration.Search;
|
|
Assert.Null(search.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(search.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var to in search.To ?? Array.Empty<Models.OfflineList.To>())
|
|
{
|
|
Assert.Null(to.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(to.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var find in to.Find ?? Array.Empty<Models.OfflineList.Find>())
|
|
{
|
|
Assert.Null(find.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(find.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Assert.Null(dat.Games.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dat.Games.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var game in dat.Games.Game)
|
|
{
|
|
Assert.Null(game.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(game.ADDITIONAL_ELEMENTS);
|
|
|
|
if (game.Files != null)
|
|
{
|
|
var files = game.Files;
|
|
Assert.Null(files.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(files.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var romCRC in files.RomCRC ?? Array.Empty<Models.OfflineList.FileRomCRC>())
|
|
{
|
|
Assert.Null(romCRC.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(romCRC.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dat.GUI != null)
|
|
{
|
|
var gui = dat.GUI;
|
|
Assert.Null(gui.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(gui.ADDITIONAL_ELEMENTS);
|
|
|
|
if (gui.Images != null)
|
|
{
|
|
var images = gui.Images;
|
|
Assert.Null(images.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(images.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var image in images.Image ?? Array.Empty<Models.OfflineList.Image>())
|
|
{
|
|
Assert.Null(image.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(image.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-openmsx-files.xml", 2550)]
|
|
public void OpenMSXDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.OpenMSX.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat);
|
|
Assert.NotNull(dat.Software);
|
|
Assert.Equal(count, dat.Software.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Null(dat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dat.ADDITIONAL_ELEMENTS);
|
|
foreach (var software in dat.Software)
|
|
{
|
|
Assert.Null(software.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(software.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var dump in software.Dump ?? Array.Empty<Models.OpenMSX.Dump>())
|
|
{
|
|
Assert.Null(dump.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dump.ADDITIONAL_ELEMENTS);
|
|
|
|
if (dump.Original != null)
|
|
{
|
|
Assert.Null(dump.Original.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dump.Original.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
if (dump.Rom != null)
|
|
{
|
|
Assert.Null(dump.Rom.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dump.Rom.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-romcenter-files.dat", 901)]
|
|
public void RomCenterDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.RomCenter.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat?.Games?.Rom);
|
|
Assert.Equal(count, dat.Games.Rom.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Empty(dat.ADDITIONAL_ELEMENTS);
|
|
if (dat.Credits != null)
|
|
Assert.Empty(dat.Credits.ADDITIONAL_ELEMENTS);
|
|
|
|
if (dat.Dat != null)
|
|
Assert.Empty(dat.Dat.ADDITIONAL_ELEMENTS);
|
|
|
|
if (dat.Emulator != null)
|
|
Assert.Empty(dat.Emulator.ADDITIONAL_ELEMENTS);
|
|
|
|
if (dat.Games != null)
|
|
{
|
|
Assert.Empty(dat.Games.ADDITIONAL_ELEMENTS);
|
|
foreach (var rom in dat.Games.Rom ?? Array.Empty<Models.RomCenter.Rom>())
|
|
{
|
|
Assert.Null(rom.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("test-softwarelist-files1.xml", 4531)]
|
|
[InlineData("test-softwarelist-files2.xml", 2797)]
|
|
[InlineData("test-softwarelist-files3.xml", 274)]
|
|
public void SoftwareListDeserializeTest(string path, long count)
|
|
{
|
|
// Open the file for reading
|
|
string filename = System.IO.Path.Combine(Environment.CurrentDirectory, "TestData", path);
|
|
|
|
// Deserialize the file
|
|
var dat = Serialization.SoftawreList.Deserialize(filename);
|
|
|
|
// Validate the values
|
|
Assert.NotNull(dat);
|
|
Assert.NotNull(dat.Software);
|
|
Assert.Equal(count, dat.Software.Length);
|
|
|
|
// Validate we're not missing any attributes or elements
|
|
Assert.Null(dat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dat.ADDITIONAL_ELEMENTS);
|
|
foreach (var software in dat.Software)
|
|
{
|
|
Assert.Null(software.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(software.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var info in software.Info ?? Array.Empty<Models.SoftwareList.Info>())
|
|
{
|
|
Assert.Null(info.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(info.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var sharedfeat in software.SharedFeat ?? Array.Empty<Models.SoftwareList.SharedFeat>())
|
|
{
|
|
Assert.Null(sharedfeat.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(sharedfeat.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var part in software.Part ?? Array.Empty<Models.SoftwareList.Part>())
|
|
{
|
|
Assert.Null(part.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(part.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var feature in part.Feature ?? Array.Empty<Models.SoftwareList.Feature>())
|
|
{
|
|
Assert.Null(feature.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(feature.ADDITIONAL_ELEMENTS);
|
|
}
|
|
|
|
foreach (var dataarea in part.DataArea ?? Array.Empty<Models.SoftwareList.DataArea>())
|
|
{
|
|
Assert.Null(dataarea.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dataarea.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var rom in dataarea.Rom ?? Array.Empty<Models.SoftwareList.Rom>())
|
|
{
|
|
Assert.Null(rom.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(rom.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var diskarea in part.DiskArea ?? Array.Empty<Models.SoftwareList.DiskArea>())
|
|
{
|
|
Assert.Null(diskarea.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(diskarea.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var disk in diskarea.Disk ?? Array.Empty<Models.SoftwareList.Disk>())
|
|
{
|
|
Assert.Null(disk.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(disk.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
|
|
foreach (var dipswitch in part.DipSwitch ?? Array.Empty<Models.SoftwareList.DipSwitch>())
|
|
{
|
|
Assert.Null(dipswitch.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dipswitch.ADDITIONAL_ELEMENTS);
|
|
|
|
foreach (var dipvalue in dipswitch.DipValue ?? Array.Empty<Models.SoftwareList.DipValue>())
|
|
{
|
|
Assert.Null(dipvalue.ADDITIONAL_ATTRIBUTES);
|
|
Assert.Null(dipvalue.ADDITIONAL_ELEMENTS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |