mirror of
https://github.com/SabreTools/SabreTools.Serialization.git
synced 2026-07-09 02:16:55 +00:00
Port metadata functionality from ST
This commit is contained in:
Matt Nadareski
23
SabreTools.Metadata.DatFiles.Test/ConvertersTests.cs
Normal file
23
SabreTools.Metadata.DatFiles.Test/ConvertersTests.cs
Normal file
@@ -0,0 +1,23 @@
|
||||
using SabreTools.Metadata.Tools;
|
||||
using Xunit;
|
||||
|
||||
namespace SabreTools.Metadata.DatFiles.Test
|
||||
{
|
||||
public class ConvertersTests
|
||||
{
|
||||
#region Generators
|
||||
|
||||
[Theory]
|
||||
[InlineData(MergingFlag.None, 12)]
|
||||
[InlineData(NodumpFlag.None, 4)]
|
||||
[InlineData(PackingFlag.None, 8)]
|
||||
public void GenerateToEnumTest<T>(T value, int expected)
|
||||
{
|
||||
var actual = Converters.GenerateToEnum<T>();
|
||||
Assert.Equal(default, value);
|
||||
Assert.Equal(expected, actual.Keys.Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
304
SabreTools.Metadata.DatFiles.Test/DatFileTests.Filtering.cs
Normal file
304
SabreTools.Metadata.DatFiles.Test/DatFileTests.Filtering.cs
Normal file
@@ -0,0 +1,304 @@
|
||||
using System.Collections.Generic;
|
||||
using SabreTools.Metadata.DatFiles.Formats;
|
||||
using SabreTools.Metadata.DatItems;
|
||||
using SabreTools.Metadata.DatItems.Formats;
|
||||
using SabreTools.Metadata.Filter;
|
||||
using Xunit;
|
||||
|
||||
namespace SabreTools.Metadata.DatFiles.Test
|
||||
{
|
||||
public partial class DatFileTests
|
||||
{
|
||||
#region ExecuteFilters
|
||||
|
||||
[Fact]
|
||||
public void ExecuteFilters_Items()
|
||||
{
|
||||
FilterObject filterObject = new FilterObject("rom.crc", "deadbeef", Operation.NotEquals);
|
||||
FilterRunner filterRunner = new FilterRunner([filterObject]);
|
||||
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetName("rom.bin");
|
||||
datItem.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
datItem.SetFieldValue(DatItem.MachineKey, machine);
|
||||
datItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(datItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.ExecuteFilters(filterRunner);
|
||||
|
||||
var actualDatItems = datFile.GetItemsForBucket("machine");
|
||||
DatItem actualRom = Assert.Single(actualDatItems);
|
||||
Assert.Equal(true, actualRom.GetBoolFieldValue(DatItem.RemoveKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ExecuteFilters_ItemsDB()
|
||||
{
|
||||
FilterObject filterObject = new FilterObject("rom.crc", "deadbeef", Operation.NotEquals);
|
||||
FilterRunner filterRunner = new FilterRunner([filterObject]);
|
||||
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetName("rom.bin");
|
||||
datItem.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
datItem.SetFieldValue(DatItem.MachineKey, machine);
|
||||
datItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
long machineIndex = datFile.AddMachineDB(machine);
|
||||
_ = datFile.AddItemDB(datItem, machineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.ExecuteFilters(filterRunner);
|
||||
|
||||
var actualDatItems = datFile.GetItemsForBucketDB("machine");
|
||||
DatItem actualRom = Assert.Single(actualDatItems).Value;
|
||||
Assert.Equal(true, actualRom.GetBoolFieldValue(DatItem.RemoveKey));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region MachineDescriptionToName
|
||||
|
||||
[Fact]
|
||||
public void MachineDescriptionToName_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine");
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.DescriptionKey, "description");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetFieldValue(DatItem.MachineKey, machine);
|
||||
datItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(datItem, statsOnly: false);
|
||||
|
||||
datFile.MachineDescriptionToName();
|
||||
|
||||
// The name of the bucket is not expected to change
|
||||
DatItem actual = Assert.Single(datFile.GetItemsForBucket("machine"));
|
||||
Machine? actualMachine = actual.GetMachine();
|
||||
Assert.NotNull(actualMachine);
|
||||
Assert.Equal("description", actualMachine.GetName());
|
||||
Assert.Equal("description", actualMachine.GetStringFieldValue(Data.Models.Metadata.Machine.DescriptionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MachineDescriptionToName_ItemsDB()
|
||||
{
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine");
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.DescriptionKey, "description");
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
_ = datFile.AddMachineDB(machine);
|
||||
|
||||
datFile.MachineDescriptionToName();
|
||||
|
||||
Machine actualMachine = Assert.Single(datFile.GetMachinesDB()).Value;
|
||||
Assert.Equal("description", actualMachine.GetName());
|
||||
Assert.Equal("description", actualMachine.GetStringFieldValue(Data.Models.Metadata.Machine.DescriptionKey));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region SetOneRomPerGame
|
||||
|
||||
[Fact]
|
||||
public void SetOneRomPerGame_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine");
|
||||
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("rom.bin");
|
||||
rom.SetFieldValue(DatItem.MachineKey, machine);
|
||||
rom.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem disk = new Disk();
|
||||
disk.SetName("disk");
|
||||
disk.SetFieldValue(DatItem.MachineKey, machine);
|
||||
disk.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(rom, statsOnly: false);
|
||||
datFile.AddItem(disk, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.SetOneRomPerGame();
|
||||
|
||||
var actualDatItems = datFile.GetItemsForBucket("machine");
|
||||
Assert.Equal(2, actualDatItems.Count);
|
||||
|
||||
DatItem actualRom = Assert.Single(actualDatItems.FindAll(i => i is Rom));
|
||||
Machine? actualRomMachine = actualRom.GetMachine();
|
||||
Assert.NotNull(actualRomMachine);
|
||||
Assert.Equal("machine/rom", actualRomMachine.GetName());
|
||||
|
||||
DatItem actualDisk = Assert.Single(actualDatItems.FindAll(i => i is Disk));
|
||||
Machine? actualDiskMachine = actualDisk.GetMachine();
|
||||
Assert.NotNull(actualDiskMachine);
|
||||
Assert.Equal("machine/disk", actualDiskMachine.GetName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SetOneRomPerGame_ItemsDB()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine");
|
||||
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("rom.bin");
|
||||
|
||||
DatItem disk = new Disk();
|
||||
disk.SetName("disk");
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
long machineIndex = datFile.AddMachineDB(machine);
|
||||
_ = datFile.AddItemDB(rom, machineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(disk, machineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.SetOneRomPerGame();
|
||||
|
||||
var actualDatItems = datFile.GetItemsForBucketDB("machine");
|
||||
Assert.Equal(2, actualDatItems.Count);
|
||||
|
||||
var actualRom = Assert.Single(actualDatItems, i => i.Value is Rom);
|
||||
var actualRomMachine = datFile.GetMachineForItemDB(actualRom.Key);
|
||||
Assert.NotNull(actualRomMachine.Value);
|
||||
Assert.Equal("machine/rom", actualRomMachine.Value.GetName());
|
||||
|
||||
var actualDisk = Assert.Single(actualDatItems, i => i.Value is Disk);
|
||||
var actualDiskMachine = datFile.GetMachineForItemDB(actualDisk.Key);
|
||||
Assert.NotNull(actualDiskMachine.Value);
|
||||
Assert.Equal("machine/disk", actualDiskMachine.Value.GetName());
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region SetOneGamePerRegion
|
||||
|
||||
[Fact]
|
||||
public void SetOneGamePerRegion_Items()
|
||||
{
|
||||
Machine nowhereMachine = new Machine();
|
||||
nowhereMachine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine (Nowhere)");
|
||||
|
||||
Machine worldMachine = new Machine();
|
||||
worldMachine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine (World)");
|
||||
worldMachine.SetFieldValue(Data.Models.Metadata.Machine.CloneOfKey, "machine (Nowhere)");
|
||||
|
||||
DatItem nowhereRom = new Rom();
|
||||
nowhereRom.SetName("rom.bin");
|
||||
nowhereRom.SetFieldValue(DatItem.MachineKey, nowhereMachine);
|
||||
|
||||
DatItem worldRom = new Rom();
|
||||
worldRom.SetName("rom.nib");
|
||||
worldRom.SetFieldValue(DatItem.MachineKey, worldMachine);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(nowhereRom, statsOnly: false);
|
||||
datFile.AddItem(worldRom, statsOnly: false);
|
||||
|
||||
List<string> regions = ["World", "Nowhere"];
|
||||
datFile.SetOneGamePerRegion(regions);
|
||||
|
||||
Assert.Empty(datFile.GetItemsForBucket("machine (nowhere)"));
|
||||
|
||||
var actualDatItems = datFile.GetItemsForBucket("machine (world)");
|
||||
DatItem actualWorldRom = Assert.Single(actualDatItems);
|
||||
Machine? actualWorldMachine = actualWorldRom.GetMachine();
|
||||
Assert.NotNull(actualWorldMachine);
|
||||
Assert.Equal("machine (World)", actualWorldMachine.GetName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SetOneGamePerRegion_ItemsDB()
|
||||
{
|
||||
Machine nowhereMachine = new Machine();
|
||||
nowhereMachine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine (Nowhere)");
|
||||
|
||||
Machine worldMachine = new Machine();
|
||||
worldMachine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "machine (World)");
|
||||
worldMachine.SetFieldValue(Data.Models.Metadata.Machine.CloneOfKey, "machine (Nowhere)");
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
_ = datFile.AddMachineDB(nowhereMachine);
|
||||
_ = datFile.AddMachineDB(worldMachine);
|
||||
|
||||
List<string> regions = ["World", "Nowhere"];
|
||||
datFile.SetOneGamePerRegion(regions);
|
||||
|
||||
var actualWorldMachine = Assert.Single(datFile.GetMachinesDB());
|
||||
Assert.NotNull(actualWorldMachine.Value);
|
||||
Assert.Equal("machine (World)", actualWorldMachine.Value.GetName());
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region StripSceneDatesFromItems
|
||||
|
||||
[Fact]
|
||||
public void StripSceneDatesFromItems_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "10.10.10-machine-name");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetFieldValue(DatItem.MachineKey, machine);
|
||||
datItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(datItem, statsOnly: false);
|
||||
|
||||
datFile.StripSceneDatesFromItems();
|
||||
|
||||
// The name of the bucket is not expected to change
|
||||
DatItem actual = Assert.Single(datFile.GetItemsForBucket("10.10.10-machine-name"));
|
||||
Machine? actualMachine = actual.GetMachine();
|
||||
Assert.NotNull(actualMachine);
|
||||
Assert.Equal("machine-name", actualMachine.GetName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StripSceneDatesFromItems_ItemsDB()
|
||||
{
|
||||
Machine machine = new Machine();
|
||||
machine.SetFieldValue(Data.Models.Metadata.Machine.NameKey, "10.10.10-machine-name");
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
_ = datFile.AddMachineDB(machine);
|
||||
|
||||
datFile.StripSceneDatesFromItems();
|
||||
|
||||
Machine actualMachine = Assert.Single(datFile.GetMachinesDB()).Value;
|
||||
Assert.Equal("machine-name", actualMachine.GetName());
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
1564
SabreTools.Metadata.DatFiles.Test/DatFileTests.FromMetadata.cs
Normal file
1564
SabreTools.Metadata.DatFiles.Test/DatFileTests.FromMetadata.cs
Normal file
File diff suppressed because it is too large
Load Diff
847
SabreTools.Metadata.DatFiles.Test/DatFileTests.Splitting.cs
Normal file
847
SabreTools.Metadata.DatFiles.Test/DatFileTests.Splitting.cs
Normal file
@@ -0,0 +1,847 @@
|
||||
using SabreTools.Metadata.DatFiles.Formats;
|
||||
using SabreTools.Metadata.DatItems;
|
||||
using SabreTools.Metadata.DatItems.Formats;
|
||||
using Xunit;
|
||||
|
||||
namespace SabreTools.Metadata.DatFiles.Test
|
||||
{
|
||||
public partial class DatFileTests
|
||||
{
|
||||
#region AddItemsFromChildren
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromChildren_Items_Dedup()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(parentItem, statsOnly: false);
|
||||
datFile.AddItem(matchChildItem, statsOnly: false);
|
||||
datFile.AddItem(noMatchChildItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromChildren(subfolder: true, skipDedup: false);
|
||||
|
||||
Assert.Equal(2, datFile.GetItemsForBucket("parent").Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromChildren_Items_SkipDedup()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(parentItem, statsOnly: false);
|
||||
datFile.AddItem(matchChildItem, statsOnly: false);
|
||||
datFile.AddItem(noMatchChildItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromChildren(subfolder: true, skipDedup: true);
|
||||
|
||||
Assert.Equal(3, datFile.GetItemsForBucket("parent").Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromChildren_ItemsDB_Dedup()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long biosMachineIndex = datFile.AddMachineDB(parentMachine);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(childMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromChildren(subfolder: true, skipDedup: false);
|
||||
|
||||
Assert.Equal(2, datFile.GetItemsForBucketDB("parent").Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromChildren_ItemsDB_SkipDedup()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long biosMachineIndex = datFile.AddMachineDB(parentMachine);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(childMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromChildren(subfolder: true, skipDedup: true);
|
||||
|
||||
Assert.Equal(3, datFile.GetItemsForBucketDB("parent").Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region AddItemsFromCloneOfParent
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromCloneOfParent_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(parentItem, statsOnly: false);
|
||||
datFile.AddItem(matchChildItem, statsOnly: false);
|
||||
datFile.AddItem(noMatchChildItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromCloneOfParent();
|
||||
|
||||
Assert.Equal(2, datFile.GetItemsForBucket("child").Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromCloneOfParent_ItemsDB()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long biosMachineIndex = datFile.AddMachineDB(parentMachine);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(childMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromCloneOfParent();
|
||||
|
||||
Assert.Equal(2, datFile.GetItemsForBucketDB("child").Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region AddItemsFromDevices
|
||||
|
||||
[Theory]
|
||||
[InlineData(false, false, 4)]
|
||||
[InlineData(false, true, 4)]
|
||||
[InlineData(true, false, 3)]
|
||||
[InlineData(true, true, 3)]
|
||||
public void AddItemsFromDevices_Items(bool deviceOnly, bool useSlotOptions, int expected)
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine deviceMachine = new Machine();
|
||||
deviceMachine.SetName("device");
|
||||
deviceMachine.SetFieldValue(Data.Models.Metadata.Machine.IsDeviceKey, true);
|
||||
|
||||
Machine slotOptionMachine = new Machine();
|
||||
slotOptionMachine.SetName("slotoption");
|
||||
|
||||
Machine itemMachine = new Machine();
|
||||
itemMachine.SetName("machine");
|
||||
|
||||
DatItem deviceItem = new Sample();
|
||||
deviceItem.SetName("device_item");
|
||||
deviceItem.SetFieldValue(DatItem.MachineKey, deviceMachine);
|
||||
deviceItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem slotOptionItem = new Sample();
|
||||
slotOptionItem.SetName("slot_option_item");
|
||||
slotOptionItem.SetFieldValue(DatItem.MachineKey, slotOptionMachine);
|
||||
slotOptionItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetName("rom");
|
||||
datItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
datItem.SetFieldValue(DatItem.MachineKey, itemMachine);
|
||||
datItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem deviceRef = new DeviceRef();
|
||||
deviceRef.SetName("device");
|
||||
deviceRef.SetFieldValue(DatItem.MachineKey, itemMachine);
|
||||
deviceRef.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem slotOption = new SlotOption();
|
||||
slotOption.SetName("slotoption");
|
||||
slotOption.SetFieldValue(DatItem.MachineKey, itemMachine);
|
||||
slotOption.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(deviceItem, statsOnly: false);
|
||||
datFile.AddItem(slotOptionItem, statsOnly: false);
|
||||
datFile.AddItem(datItem, statsOnly: false);
|
||||
datFile.AddItem(deviceRef, statsOnly: false);
|
||||
datFile.AddItem(slotOption, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromDevices(deviceOnly, useSlotOptions);
|
||||
|
||||
Assert.Equal(expected, datFile.GetItemsForBucket("machine").Count);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(false, false, 4)]
|
||||
[InlineData(false, true, 4)]
|
||||
[InlineData(true, false, 3)]
|
||||
[InlineData(true, true, 3)]
|
||||
public void AddItemsFromDevices_ItemsDB(bool deviceOnly, bool useSlotOptions, int expected)
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine deviceMachine = new Machine();
|
||||
deviceMachine.SetName("device");
|
||||
deviceMachine.SetFieldValue(Data.Models.Metadata.Machine.IsDeviceKey, true);
|
||||
|
||||
Machine slotOptionMachine = new Machine();
|
||||
slotOptionMachine.SetName("slotoption");
|
||||
|
||||
Machine itemMachine = new Machine();
|
||||
itemMachine.SetName("machine");
|
||||
|
||||
DatItem deviceItem = new Sample();
|
||||
deviceItem.SetName("device_item");
|
||||
|
||||
DatItem slotOptionItem = new Sample();
|
||||
slotOptionItem.SetName("slot_option_item");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetName("rom");
|
||||
datItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
|
||||
DatItem deviceRef = new DeviceRef();
|
||||
deviceRef.SetName("device");
|
||||
|
||||
DatItem slotOption = new SlotOption();
|
||||
slotOption.SetName("slotoption");
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(deviceMachine);
|
||||
long slotOptionMachineIndex = datFile.AddMachineDB(slotOptionMachine);
|
||||
long itemMachineIndex = datFile.AddMachineDB(itemMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(deviceItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(slotOptionItem, slotOptionMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(datItem, itemMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(deviceRef, itemMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(slotOption, itemMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromDevices(deviceOnly, useSlotOptions);
|
||||
|
||||
Assert.Equal(expected, datFile.GetItemsForBucketDB("machine").Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region AddItemsFromRomOfParent
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromRomOfParent_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(parentItem, statsOnly: false);
|
||||
datFile.AddItem(matchChildItem, statsOnly: false);
|
||||
datFile.AddItem(noMatchChildItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromRomOfParent();
|
||||
|
||||
Assert.Equal(2, datFile.GetItemsForBucket("child").Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItemsFromRomOfParent_ItemsDB()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long biosMachineIndex = datFile.AddMachineDB(parentMachine);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(childMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.AddItemsFromRomOfParent();
|
||||
|
||||
Assert.Equal(2, datFile.GetItemsForBucketDB("child").Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region RemoveBiosAndDeviceSets
|
||||
|
||||
[Fact]
|
||||
public void RemoveBiosAndDeviceSets_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine biosMachine = new Machine();
|
||||
biosMachine.SetName("bios");
|
||||
biosMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
Machine deviceMachine = new Machine();
|
||||
deviceMachine.SetName("device");
|
||||
deviceMachine.SetFieldValue(Data.Models.Metadata.Machine.IsDeviceKey, true);
|
||||
|
||||
DatItem biosItem = new Rom();
|
||||
biosItem.SetFieldValue(DatItem.MachineKey, biosMachine);
|
||||
biosItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem deviceItem = new Rom();
|
||||
deviceItem.SetFieldValue(DatItem.MachineKey, deviceMachine);
|
||||
deviceItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(biosItem, statsOnly: false);
|
||||
datFile.AddItem(deviceItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveBiosAndDeviceSets();
|
||||
|
||||
Assert.Empty(datFile.GetItemsForBucket("bios"));
|
||||
Assert.Empty(datFile.GetItemsForBucket("device"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RemoveBiosAndDeviceSets_ItemsDB()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine biosMachine = new Machine();
|
||||
biosMachine.SetName("bios");
|
||||
biosMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
Machine deviceMachine = new Machine();
|
||||
deviceMachine.SetName("device");
|
||||
deviceMachine.SetFieldValue(Data.Models.Metadata.Machine.IsDeviceKey, true);
|
||||
|
||||
DatItem biosItem = new Rom();
|
||||
DatItem deviceItem = new Rom();
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long biosMachineIndex = datFile.AddMachineDB(biosMachine);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(deviceMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(biosItem, biosMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(deviceItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveBiosAndDeviceSets();
|
||||
|
||||
Assert.Empty(datFile.GetMachinesDB());
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region RemoveItemsFromCloneOfChild
|
||||
|
||||
[Fact]
|
||||
public void RemoveItemsFromCloneOfChild_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
parentMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "romof");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(parentItem, statsOnly: false);
|
||||
datFile.AddItem(matchChildItem, statsOnly: false);
|
||||
datFile.AddItem(noMatchChildItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveItemsFromCloneOfChild();
|
||||
|
||||
Assert.Single(datFile.GetItemsForBucket("parent"));
|
||||
DatItem actual = Assert.Single(datFile.GetItemsForBucket("child"));
|
||||
Machine? actualMachine = actual.GetMachine();
|
||||
Assert.NotNull(actualMachine);
|
||||
Assert.Equal("child", actualMachine.GetName());
|
||||
Assert.Equal("romof", actualMachine.GetStringFieldValue(Data.Models.Metadata.Machine.RomOfKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RemoveItemsFromCloneOfChild_ItemsDB()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
parentMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "romof");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "parent");
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long biosMachineIndex = datFile.AddMachineDB(parentMachine);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(childMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveItemsFromCloneOfChild();
|
||||
|
||||
Assert.Single(datFile.GetItemsForBucketDB("parent"));
|
||||
long actual = Assert.Single(datFile.GetItemsForBucketDB("child")).Key;
|
||||
Machine? actualMachine = datFile.GetMachineForItemDB(actual).Value;
|
||||
Assert.NotNull(actualMachine);
|
||||
Assert.Equal("child", actualMachine.GetName());
|
||||
Assert.Equal("romof", actualMachine.GetStringFieldValue(Data.Models.Metadata.Machine.RomOfKey));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region RemoveItemsFromRomOfChild
|
||||
|
||||
[Fact]
|
||||
public void RemoveItemsFromRomOfChild_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(parentItem, statsOnly: false);
|
||||
datFile.AddItem(matchChildItem, statsOnly: false);
|
||||
datFile.AddItem(noMatchChildItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveItemsFromRomOfChild();
|
||||
|
||||
Assert.Single(datFile.GetItemsForBucket("parent"));
|
||||
DatItem actual = Assert.Single(datFile.GetItemsForBucket("child"));
|
||||
Machine? actualMachine = actual.GetMachine();
|
||||
Assert.NotNull(actualMachine);
|
||||
Assert.Equal("child", actualMachine.GetName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RemoveItemsFromRomOfChild_ItemsDB()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine parentMachine = new Machine();
|
||||
parentMachine.SetName("parent");
|
||||
|
||||
Machine childMachine = new Machine();
|
||||
childMachine.SetName("child");
|
||||
childMachine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "parent");
|
||||
childMachine.SetFieldValue(Data.Models.Metadata.Machine.IsBiosKey, true);
|
||||
|
||||
DatItem parentItem = new Rom();
|
||||
parentItem.SetName("parent_rom");
|
||||
parentItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
parentItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
parentItem.SetFieldValue(DatItem.MachineKey, parentMachine);
|
||||
parentItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem matchChildItem = new Rom();
|
||||
matchChildItem.SetName("match_child_rom");
|
||||
matchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
matchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
matchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
matchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatItem noMatchChildItem = new Rom();
|
||||
noMatchChildItem.SetName("no_match_child_rom");
|
||||
noMatchChildItem.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
noMatchChildItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "beefdead");
|
||||
noMatchChildItem.SetFieldValue(DatItem.MachineKey, childMachine);
|
||||
noMatchChildItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long biosMachineIndex = datFile.AddMachineDB(parentMachine);
|
||||
long deviceMachineIndex = datFile.AddMachineDB(childMachine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
_ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveItemsFromRomOfChild();
|
||||
|
||||
Assert.Single(datFile.GetItemsForBucketDB("parent"));
|
||||
long actual = Assert.Single(datFile.GetItemsForBucketDB("child")).Key;
|
||||
Machine? actualMachine = datFile.GetMachineForItemDB(actual).Value;
|
||||
Assert.NotNull(actualMachine);
|
||||
Assert.Equal("child", actualMachine.GetName());
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region RemoveMachineRelationshipTags
|
||||
|
||||
[Fact]
|
||||
public void RemoveMachineRelationshipTags_Items()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
machine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "XXXXXX");
|
||||
machine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "XXXXXX");
|
||||
machine.SetFieldValue<string?>(Data.Models.Metadata.Machine.SampleOfKey, "XXXXXX");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetFieldValue(DatItem.MachineKey, machine);
|
||||
datItem.SetFieldValue(DatItem.SourceKey, source);
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
datFile.AddItem(datItem, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveMachineRelationshipTags();
|
||||
|
||||
DatItem actualItem = Assert.Single(datFile.GetItemsForBucket("machine"));
|
||||
Machine? actual = actualItem.GetMachine();
|
||||
Assert.NotNull(actual);
|
||||
Assert.Null(actual.GetStringFieldValue(Data.Models.Metadata.Machine.CloneOfKey));
|
||||
Assert.Null(actual.GetStringFieldValue(Data.Models.Metadata.Machine.RomOfKey));
|
||||
Assert.Null(actual.GetStringFieldValue(Data.Models.Metadata.Machine.SampleOfKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RemoveMachineRelationshipTags_ItemsDB()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
machine.SetFieldValue<string?>(Data.Models.Metadata.Machine.CloneOfKey, "XXXXXX");
|
||||
machine.SetFieldValue<string?>(Data.Models.Metadata.Machine.RomOfKey, "XXXXXX");
|
||||
machine.SetFieldValue<string?>(Data.Models.Metadata.Machine.SampleOfKey, "XXXXXX");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
|
||||
DatFile datFile = new Logiqx(datFile: null, useGame: false);
|
||||
long machineIndex = datFile.AddMachineDB(machine);
|
||||
long sourceIndex = datFile.AddSourceDB(source);
|
||||
_ = datFile.AddItemDB(datItem, machineIndex, sourceIndex, statsOnly: false);
|
||||
|
||||
datFile.BucketBy(ItemKey.Machine);
|
||||
datFile.RemoveMachineRelationshipTags();
|
||||
|
||||
Machine actual = Assert.Single(datFile.GetMachinesDB()).Value;
|
||||
Assert.Null(actual.GetStringFieldValue(Data.Models.Metadata.Machine.CloneOfKey));
|
||||
Assert.Null(actual.GetStringFieldValue(Data.Models.Metadata.Machine.RomOfKey));
|
||||
Assert.Null(actual.GetStringFieldValue(Data.Models.Metadata.Machine.SampleOfKey));
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
1166
SabreTools.Metadata.DatFiles.Test/DatFileTests.ToMetadata.cs
Normal file
1166
SabreTools.Metadata.DatFiles.Test/DatFileTests.ToMetadata.cs
Normal file
File diff suppressed because it is too large
Load Diff
2343
SabreTools.Metadata.DatFiles.Test/DatFileTests.cs
Normal file
2343
SabreTools.Metadata.DatFiles.Test/DatFileTests.cs
Normal file
File diff suppressed because it is too large
Load Diff
211
SabreTools.Metadata.DatFiles.Test/DatHeaderTests.cs
Normal file
211
SabreTools.Metadata.DatFiles.Test/DatHeaderTests.cs
Normal file
@@ -0,0 +1,211 @@
|
||||
using Xunit;
|
||||
|
||||
namespace SabreTools.Metadata.DatFiles.Test
|
||||
{
|
||||
public class DatHeaderTests
|
||||
{
|
||||
#region CanOpenSpecified
|
||||
|
||||
[Fact]
|
||||
public void CanOpenSpecified_Missing()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<string[]>(Data.Models.Metadata.Header.CanOpenKey, null);
|
||||
Assert.False(header.CanOpenSpecified);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CanOpenSpecified_Empty()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<string[]>(Data.Models.Metadata.Header.CanOpenKey, []);
|
||||
Assert.False(header.CanOpenSpecified);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CanOpenSpecified_Exists()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<string[]>(Data.Models.Metadata.Header.CanOpenKey, ["value"]);
|
||||
Assert.True(header.CanOpenSpecified);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region ImagesSpecified
|
||||
|
||||
[Fact]
|
||||
public void ImagesSpecified_Missing()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.Images>(Data.Models.Metadata.Header.ImagesKey, null);
|
||||
Assert.False(header.ImagesSpecified);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ImagesSpecified_Exists()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.Images>(Data.Models.Metadata.Header.ImagesKey, new());
|
||||
Assert.True(header.ImagesSpecified);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region InfosSpecified
|
||||
|
||||
[Fact]
|
||||
public void InfosSpecified_Missing()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.Infos>(Data.Models.Metadata.Header.InfosKey, null);
|
||||
Assert.False(header.InfosSpecified);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void InfosSpecified_Exists()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.Infos>(Data.Models.Metadata.Header.InfosKey, new());
|
||||
Assert.True(header.InfosSpecified);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region NewDatSpecified
|
||||
|
||||
[Fact]
|
||||
public void NewDatSpecified_Missing()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.NewDat>(Data.Models.Metadata.Header.NewDatKey, null);
|
||||
Assert.False(header.NewDatSpecified);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NewDatSpecified_Exists()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.NewDat>(Data.Models.Metadata.Header.NewDatKey, new());
|
||||
Assert.True(header.NewDatSpecified);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region SearchSpecified
|
||||
|
||||
[Fact]
|
||||
public void SearchSpecified_Missing()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.Search>(Data.Models.Metadata.Header.SearchKey, null);
|
||||
Assert.False(header.SearchSpecified);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SearchSpecified_Exists()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue<Data.Models.OfflineList.Search>(Data.Models.Metadata.Header.SearchKey, new());
|
||||
Assert.True(header.SearchSpecified);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Clone
|
||||
|
||||
[Fact]
|
||||
public void CloneTest()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue(Data.Models.Metadata.Header.NameKey, "name");
|
||||
|
||||
object clone = header.Clone();
|
||||
DatHeader? actual = clone as DatHeader;
|
||||
Assert.NotNull(actual);
|
||||
Assert.Equal("name", actual.GetStringFieldValue(Data.Models.Metadata.Header.NameKey));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region CloneFormat
|
||||
|
||||
[Fact]
|
||||
public void CloneFormatTest()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue(DatHeader.DatFormatKey, DatFormat.Logiqx);
|
||||
|
||||
object clone = header.Clone();
|
||||
DatHeader? actual = clone as DatHeader;
|
||||
Assert.NotNull(actual);
|
||||
Assert.Equal(DatFormat.Logiqx, actual.GetFieldValue<DatFormat>(DatHeader.DatFormatKey));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region GetInternalClone
|
||||
|
||||
[Fact]
|
||||
public void GetInternalCloneTest()
|
||||
{
|
||||
DatHeader header = new DatHeader();
|
||||
header.SetFieldValue(Data.Models.Metadata.Header.NameKey, "name");
|
||||
|
||||
Data.Models.Metadata.Header actual = header.GetInternalClone();
|
||||
Assert.Equal("name", actual[Data.Models.Metadata.Header.NameKey]);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Equals
|
||||
|
||||
[Fact]
|
||||
public void Equals_Null_False()
|
||||
{
|
||||
DatHeader self = new DatHeader();
|
||||
DatHeader? other = null;
|
||||
|
||||
bool actual = self.Equals(other);
|
||||
Assert.False(actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Equals_DefaultInternal_True()
|
||||
{
|
||||
DatHeader self = new DatHeader();
|
||||
DatHeader? other = new DatHeader();
|
||||
|
||||
bool actual = self.Equals(other);
|
||||
Assert.True(actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Equals_MismatchedInternal_False()
|
||||
{
|
||||
DatHeader self = new DatHeader();
|
||||
self.SetFieldValue(Data.Models.Metadata.Header.NameKey, "self");
|
||||
|
||||
DatHeader? other = new DatHeader();
|
||||
other.SetFieldValue(Data.Models.Metadata.Header.NameKey, "other");
|
||||
|
||||
bool actual = self.Equals(other);
|
||||
Assert.False(actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Equals_EqualInternal_True()
|
||||
{
|
||||
DatHeader self = new DatHeader();
|
||||
self.SetFieldValue(Data.Models.Metadata.Header.NameKey, "name");
|
||||
|
||||
DatHeader? other = new DatHeader();
|
||||
other.SetFieldValue(Data.Models.Metadata.Header.NameKey, "name");
|
||||
|
||||
bool actual = self.Equals(other);
|
||||
Assert.True(actual);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
326
SabreTools.Metadata.DatFiles.Test/DatStatisticsTests.cs
Normal file
326
SabreTools.Metadata.DatFiles.Test/DatStatisticsTests.cs
Normal file
@@ -0,0 +1,326 @@
|
||||
using SabreTools.Hashing;
|
||||
using SabreTools.Metadata.DatItems;
|
||||
using SabreTools.Metadata.DatItems.Formats;
|
||||
using Xunit;
|
||||
|
||||
namespace SabreTools.Metadata.DatFiles.Test
|
||||
{
|
||||
public class DatStatisticsTests
|
||||
{
|
||||
#region Constructor
|
||||
|
||||
[Fact]
|
||||
public void DefaultConstructorTest()
|
||||
{
|
||||
var stats = new DatStatistics();
|
||||
|
||||
Assert.Null(stats.DisplayName);
|
||||
Assert.Equal(0, stats.MachineCount);
|
||||
Assert.False(stats.IsDirectory);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NamedConstructorTest()
|
||||
{
|
||||
var stats = new DatStatistics("name", isDirectory: true);
|
||||
|
||||
Assert.Equal("name", stats.DisplayName);
|
||||
Assert.Equal(0, stats.MachineCount);
|
||||
Assert.True(stats.IsDirectory);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region End to End
|
||||
|
||||
[Fact]
|
||||
public void AddRemoveStatisticsTest()
|
||||
{
|
||||
// Get items for testing
|
||||
var disk = CreateDisk();
|
||||
var file = CreateFile();
|
||||
var media = CreateMedia();
|
||||
var rom = CreateRom();
|
||||
var sample = CreateSample();
|
||||
|
||||
// Create an empty stats object
|
||||
var stats = new DatStatistics();
|
||||
|
||||
// Validate pre-add values
|
||||
Assert.Equal(0, stats.TotalCount);
|
||||
Assert.Equal(0, stats.TotalSize);
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD2));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD4));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD5));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD128));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD160));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA1));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA256));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA384));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA512));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SpamSum));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Disk));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.File));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Media));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Sample));
|
||||
Assert.Equal(0, stats.GetStatusCount(ItemStatus.Good));
|
||||
|
||||
// AddItemStatistics
|
||||
stats.AddItemStatistics(disk);
|
||||
stats.AddItemStatistics(file);
|
||||
stats.AddItemStatistics(media);
|
||||
stats.AddItemStatistics(rom);
|
||||
stats.AddItemStatistics(sample);
|
||||
|
||||
// Validate post-add values
|
||||
Assert.Equal(5, stats.TotalCount);
|
||||
Assert.Equal(2, stats.TotalSize);
|
||||
Assert.Equal(2, stats.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.MD2));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.MD4));
|
||||
Assert.Equal(4, stats.GetHashCount(HashType.MD5));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.RIPEMD128));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.RIPEMD160));
|
||||
Assert.Equal(4, stats.GetHashCount(HashType.SHA1));
|
||||
Assert.Equal(3, stats.GetHashCount(HashType.SHA256));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.SHA384));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.SHA512));
|
||||
Assert.Equal(2, stats.GetHashCount(HashType.SpamSum));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Disk));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.File));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Media));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Sample));
|
||||
Assert.Equal(2, stats.GetStatusCount(ItemStatus.Good));
|
||||
|
||||
// RemoveItemStatistics
|
||||
stats.RemoveItemStatistics(disk);
|
||||
stats.RemoveItemStatistics(file);
|
||||
stats.RemoveItemStatistics(media);
|
||||
stats.RemoveItemStatistics(rom);
|
||||
stats.RemoveItemStatistics(sample);
|
||||
|
||||
// Validate post-remove values
|
||||
Assert.Equal(0, stats.TotalCount);
|
||||
Assert.Equal(0, stats.TotalSize);
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD2));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD4));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD5));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD128));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD160));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA1));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA256));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA384));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA512));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SpamSum));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Disk));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.File));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Media));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Sample));
|
||||
Assert.Equal(0, stats.GetStatusCount(ItemStatus.Good));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ResetStatisticsTest()
|
||||
{
|
||||
// Get items for testing
|
||||
var disk = CreateDisk();
|
||||
var file = CreateFile();
|
||||
var media = CreateMedia();
|
||||
var rom = CreateRom();
|
||||
var sample = CreateSample();
|
||||
|
||||
// Create an empty stats object
|
||||
var stats = new DatStatistics();
|
||||
|
||||
// Validate pre-add values
|
||||
Assert.Equal(0, stats.TotalCount);
|
||||
Assert.Equal(0, stats.TotalSize);
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD2));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD4));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD5));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD128));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD160));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA1));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA256));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA384));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA512));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SpamSum));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Disk));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.File));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Media));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Sample));
|
||||
Assert.Equal(0, stats.GetStatusCount(ItemStatus.Good));
|
||||
|
||||
// AddItemStatistics
|
||||
stats.AddItemStatistics(disk);
|
||||
stats.AddItemStatistics(file);
|
||||
stats.AddItemStatistics(media);
|
||||
stats.AddItemStatistics(rom);
|
||||
stats.AddItemStatistics(sample);
|
||||
|
||||
// Validate post-add values
|
||||
Assert.Equal(5, stats.TotalCount);
|
||||
Assert.Equal(2, stats.TotalSize);
|
||||
Assert.Equal(2, stats.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.MD2));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.MD4));
|
||||
Assert.Equal(4, stats.GetHashCount(HashType.MD5));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.RIPEMD128));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.RIPEMD160));
|
||||
Assert.Equal(4, stats.GetHashCount(HashType.SHA1));
|
||||
Assert.Equal(3, stats.GetHashCount(HashType.SHA256));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.SHA384));
|
||||
Assert.Equal(1, stats.GetHashCount(HashType.SHA512));
|
||||
Assert.Equal(2, stats.GetHashCount(HashType.SpamSum));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Disk));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.File));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Media));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(1, stats.GetItemCount(ItemType.Sample));
|
||||
Assert.Equal(2, stats.GetStatusCount(ItemStatus.Good));
|
||||
|
||||
// ResetStatistics
|
||||
stats.ResetStatistics();
|
||||
|
||||
// Validate post-reset values
|
||||
Assert.Equal(0, stats.TotalCount);
|
||||
Assert.Equal(0, stats.TotalSize);
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD2));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD4));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.MD5));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD128));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.RIPEMD160));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA1));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA256));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA384));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SHA512));
|
||||
Assert.Equal(0, stats.GetHashCount(HashType.SpamSum));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Disk));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.File));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Media));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(0, stats.GetItemCount(ItemType.Sample));
|
||||
Assert.Equal(0, stats.GetStatusCount(ItemStatus.Good));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region AddStatistics
|
||||
|
||||
[Fact]
|
||||
public void AddStatisticsTest()
|
||||
{
|
||||
var rom = CreateRom();
|
||||
var origStats = new DatStatistics();
|
||||
origStats.AddItemStatistics(rom);
|
||||
|
||||
var newStats = new DatStatistics();
|
||||
newStats.AddStatistics(origStats);
|
||||
|
||||
Assert.Equal(1, newStats.TotalCount);
|
||||
Assert.Equal(1, newStats.TotalSize);
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.MD2));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.MD4));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.MD5));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.RIPEMD128));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.RIPEMD160));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.SHA1));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.SHA256));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.SHA384));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.SHA512));
|
||||
Assert.Equal(1, newStats.GetHashCount(HashType.SpamSum));
|
||||
Assert.Equal(1, newStats.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(1, newStats.GetStatusCount(ItemStatus.Good));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Helpers
|
||||
|
||||
/// <summary>
|
||||
/// Create a Disk for testing
|
||||
/// </summary>
|
||||
private static Disk CreateDisk()
|
||||
{
|
||||
var disk = new Disk();
|
||||
|
||||
disk.SetFieldValue<string?>(Data.Models.Metadata.Disk.StatusKey, ItemStatus.Good.AsStringValue());
|
||||
disk.SetFieldValue<string?>(Data.Models.Metadata.Disk.MD5Key, HashType.MD5.ZeroString);
|
||||
disk.SetFieldValue<string?>(Data.Models.Metadata.Disk.SHA1Key, HashType.SHA1.ZeroString);
|
||||
|
||||
return disk;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a File for testing
|
||||
/// </summary>
|
||||
private static File CreateFile()
|
||||
{
|
||||
var file = new File
|
||||
{
|
||||
Size = 1,
|
||||
CRC = HashType.CRC32.ZeroString,
|
||||
MD5 = HashType.MD5.ZeroString,
|
||||
SHA1 = HashType.SHA1.ZeroString,
|
||||
SHA256 = HashType.SHA256.ZeroString
|
||||
};
|
||||
|
||||
return file;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a Media for testing
|
||||
/// </summary>
|
||||
private static Media CreateMedia()
|
||||
{
|
||||
var media = new Media();
|
||||
|
||||
media.SetFieldValue<string?>(Data.Models.Metadata.Media.MD5Key, HashType.MD5.ZeroString);
|
||||
media.SetFieldValue<string?>(Data.Models.Metadata.Media.SHA1Key, HashType.SHA1.ZeroString);
|
||||
media.SetFieldValue<string?>(Data.Models.Metadata.Media.SHA256Key, HashType.SHA256.ZeroString);
|
||||
media.SetFieldValue<string?>(Data.Models.Metadata.Media.SpamSumKey, HashType.SpamSum.ZeroString);
|
||||
|
||||
return media;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a Rom for testing
|
||||
/// </summary>
|
||||
private static Rom CreateRom()
|
||||
{
|
||||
var rom = new Rom();
|
||||
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.StatusKey, ItemStatus.Good.AsStringValue());
|
||||
rom.SetFieldValue<long>(Data.Models.Metadata.Rom.SizeKey, 1);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, HashType.CRC32.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.MD2Key, HashType.MD2.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.MD4Key, HashType.MD4.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.MD5Key, HashType.MD5.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.RIPEMD128Key, HashType.RIPEMD128.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.RIPEMD160Key, HashType.RIPEMD160.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, HashType.SHA1.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA256Key, HashType.SHA256.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA384Key, HashType.SHA384.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA512Key, HashType.SHA512.ZeroString);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SpamSumKey, HashType.SpamSum.ZeroString);
|
||||
|
||||
return rom;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a Sample for testing
|
||||
/// </summary>
|
||||
private static Sample CreateSample() => new();
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
114
SabreTools.Metadata.DatFiles.Test/ExtensionsTests.cs
Normal file
114
SabreTools.Metadata.DatFiles.Test/ExtensionsTests.cs
Normal file
@@ -0,0 +1,114 @@
|
||||
using Xunit;
|
||||
|
||||
namespace SabreTools.Metadata.DatFiles.Test
|
||||
{
|
||||
public class ExtensionsTests
|
||||
{
|
||||
#region String to Enum
|
||||
|
||||
[Theory]
|
||||
[InlineData(null, MergingFlag.None)]
|
||||
[InlineData("none", MergingFlag.None)]
|
||||
[InlineData("split", MergingFlag.Split)]
|
||||
[InlineData("merged", MergingFlag.Merged)]
|
||||
[InlineData("nonmerged", MergingFlag.NonMerged)]
|
||||
[InlineData("unmerged", MergingFlag.NonMerged)]
|
||||
[InlineData("fullmerged", MergingFlag.FullMerged)]
|
||||
[InlineData("device", MergingFlag.DeviceNonMerged)]
|
||||
[InlineData("devicenonmerged", MergingFlag.DeviceNonMerged)]
|
||||
[InlineData("deviceunmerged", MergingFlag.DeviceNonMerged)]
|
||||
[InlineData("full", MergingFlag.FullNonMerged)]
|
||||
[InlineData("fullnonmerged", MergingFlag.FullNonMerged)]
|
||||
[InlineData("fullunmerged", MergingFlag.FullNonMerged)]
|
||||
public void AsMergingFlagTest(string? field, MergingFlag expected)
|
||||
{
|
||||
MergingFlag actual = field.AsMergingFlag();
|
||||
Assert.Equal(expected, actual);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(null, NodumpFlag.None)]
|
||||
[InlineData("none", NodumpFlag.None)]
|
||||
[InlineData("obsolete", NodumpFlag.Obsolete)]
|
||||
[InlineData("required", NodumpFlag.Required)]
|
||||
[InlineData("ignore", NodumpFlag.Ignore)]
|
||||
public void AsNodumpFlagTest(string? field, NodumpFlag expected)
|
||||
{
|
||||
NodumpFlag actual = field.AsNodumpFlag();
|
||||
Assert.Equal(expected, actual);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(null, PackingFlag.None)]
|
||||
[InlineData("none", PackingFlag.None)]
|
||||
[InlineData("yes", PackingFlag.Zip)]
|
||||
[InlineData("zip", PackingFlag.Zip)]
|
||||
[InlineData("no", PackingFlag.Unzip)]
|
||||
[InlineData("unzip", PackingFlag.Unzip)]
|
||||
[InlineData("partial", PackingFlag.Partial)]
|
||||
[InlineData("flat", PackingFlag.Flat)]
|
||||
[InlineData("fileonly", PackingFlag.FileOnly)]
|
||||
public void AsPackingFlagTest(string? field, PackingFlag expected)
|
||||
{
|
||||
PackingFlag actual = field.AsPackingFlag();
|
||||
Assert.Equal(expected, actual);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Enum to String
|
||||
|
||||
[Theory]
|
||||
[InlineData(MergingFlag.None, true, "none")]
|
||||
[InlineData(MergingFlag.None, false, "none")]
|
||||
[InlineData(MergingFlag.Split, true, "split")]
|
||||
[InlineData(MergingFlag.Split, false, "split")]
|
||||
[InlineData(MergingFlag.Merged, true, "merged")]
|
||||
[InlineData(MergingFlag.Merged, false, "merged")]
|
||||
[InlineData(MergingFlag.NonMerged, true, "unmerged")]
|
||||
[InlineData(MergingFlag.NonMerged, false, "nonmerged")]
|
||||
[InlineData(MergingFlag.FullMerged, true, "fullmerged")]
|
||||
[InlineData(MergingFlag.FullMerged, false, "fullmerged")]
|
||||
[InlineData(MergingFlag.DeviceNonMerged, true, "deviceunmerged")]
|
||||
[InlineData(MergingFlag.DeviceNonMerged, false, "device")]
|
||||
[InlineData(MergingFlag.FullNonMerged, true, "fullunmerged")]
|
||||
[InlineData(MergingFlag.FullNonMerged, false, "full")]
|
||||
public void FromMergingFlagTest(MergingFlag field, bool useSecond, string? expected)
|
||||
{
|
||||
string? actual = field.AsStringValue(useSecond);
|
||||
Assert.Equal(expected, actual);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(NodumpFlag.None, "none")]
|
||||
[InlineData(NodumpFlag.Obsolete, "obsolete")]
|
||||
[InlineData(NodumpFlag.Required, "required")]
|
||||
[InlineData(NodumpFlag.Ignore, "ignore")]
|
||||
public void FromNodumpFlagTest(NodumpFlag field, string? expected)
|
||||
{
|
||||
string? actual = field.AsStringValue();
|
||||
Assert.Equal(expected, actual);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(PackingFlag.None, true, "none")]
|
||||
[InlineData(PackingFlag.None, false, "none")]
|
||||
[InlineData(PackingFlag.Zip, true, "yes")]
|
||||
[InlineData(PackingFlag.Zip, false, "zip")]
|
||||
[InlineData(PackingFlag.Unzip, true, "no")]
|
||||
[InlineData(PackingFlag.Unzip, false, "unzip")]
|
||||
[InlineData(PackingFlag.Partial, true, "partial")]
|
||||
[InlineData(PackingFlag.Partial, false, "partial")]
|
||||
[InlineData(PackingFlag.Flat, true, "flat")]
|
||||
[InlineData(PackingFlag.Flat, false, "flat")]
|
||||
[InlineData(PackingFlag.FileOnly, true, "fileonly")]
|
||||
[InlineData(PackingFlag.FileOnly, false, "fileonly")]
|
||||
public void FromPackingFlagTest(PackingFlag field, bool useSecond, string? expected)
|
||||
{
|
||||
string? actual = field.AsStringValue(useSecond);
|
||||
Assert.Equal(expected, actual);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
1647
SabreTools.Metadata.DatFiles.Test/FormatsTests.cs
Normal file
1647
SabreTools.Metadata.DatFiles.Test/FormatsTests.cs
Normal file
File diff suppressed because it is too large
Load Diff
1025
SabreTools.Metadata.DatFiles.Test/ItemDictionaryDBTests.cs
Normal file
1025
SabreTools.Metadata.DatFiles.Test/ItemDictionaryDBTests.cs
Normal file
File diff suppressed because it is too large
Load Diff
818
SabreTools.Metadata.DatFiles.Test/ItemDictionaryTests.cs
Normal file
818
SabreTools.Metadata.DatFiles.Test/ItemDictionaryTests.cs
Normal file
@@ -0,0 +1,818 @@
|
||||
using System.Collections.Generic;
|
||||
using SabreTools.Hashing;
|
||||
using SabreTools.Metadata.DatItems;
|
||||
using SabreTools.Metadata.DatItems.Formats;
|
||||
using Xunit;
|
||||
|
||||
namespace SabreTools.Metadata.DatFiles.Test
|
||||
{
|
||||
public class ItemDictionaryTests
|
||||
{
|
||||
#region AddItem
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Disk_WithHashes()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem disk = new Disk();
|
||||
disk.SetName("item");
|
||||
disk.SetFieldValue<string?>(Data.Models.Metadata.Disk.SHA1Key, "deadbeef");
|
||||
disk.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
disk.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(disk, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Disk);
|
||||
Assert.Equal("none", actual.GetStringFieldValue(Data.Models.Metadata.Disk.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Disk_WithoutHashes()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem disk = new Disk();
|
||||
disk.SetName("item");
|
||||
disk.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
disk.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(disk, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Disk);
|
||||
Assert.Equal("nodump", actual.GetStringFieldValue(Data.Models.Metadata.Disk.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_File_WithHashes()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
var file = new File();
|
||||
file.SetName("item");
|
||||
file.SHA1 = "deadbeef";
|
||||
file.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
file.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(file, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is File);
|
||||
//Assert.Equal("none", actual.GetStringFieldValue(File.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_File_WithoutHashes()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem file = new File();
|
||||
file.SetName("item");
|
||||
file.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
file.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(file, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is File);
|
||||
//Assert.Equal("nodump", actual.GetStringFieldValue(File.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Media_WithHashes()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem media = new Media();
|
||||
media.SetName("item");
|
||||
media.SetFieldValue<string?>(Data.Models.Metadata.Media.SHA1Key, "deadbeef");
|
||||
media.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
media.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(media, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Media);
|
||||
//Assert.Equal("none", actual.GetStringFieldValue(Data.Models.Metadata.Media.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Media_WithoutHashes()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem media = new Media();
|
||||
media.SetName("item");
|
||||
media.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
media.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(media, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Media);
|
||||
//Assert.Equal("nodump", actual.GetStringFieldValue(Data.Models.Metadata.Media.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Rom_WithHashesWithSize()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("item");
|
||||
rom.SetFieldValue<long?>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "deadbeef");
|
||||
rom.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
rom.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(rom, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Rom);
|
||||
Assert.Equal(12345, actual.GetInt64FieldValue(Data.Models.Metadata.Rom.SizeKey));
|
||||
Assert.Equal("deadbeef", actual.GetStringFieldValue(Data.Models.Metadata.Rom.SHA1Key));
|
||||
Assert.Equal("none", actual.GetStringFieldValue(Data.Models.Metadata.Rom.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Rom_WithoutHashesWithSize()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("item");
|
||||
rom.SetFieldValue<long?>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
rom.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
rom.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(rom, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Rom);
|
||||
Assert.Equal(12345, actual.GetInt64FieldValue(Data.Models.Metadata.Rom.SizeKey));
|
||||
Assert.Null(actual.GetStringFieldValue(Data.Models.Metadata.Rom.SHA1Key));
|
||||
Assert.Equal("nodump", actual.GetStringFieldValue(Data.Models.Metadata.Rom.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Rom_WithHashesWithoutSize()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("item");
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "deadbeef");
|
||||
rom.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
rom.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(rom, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Rom);
|
||||
Assert.Null(actual.GetInt64FieldValue(Data.Models.Metadata.Rom.SizeKey));
|
||||
Assert.Equal("deadbeef", actual.GetStringFieldValue(Data.Models.Metadata.Rom.SHA1Key));
|
||||
Assert.Equal("none", actual.GetStringFieldValue(Data.Models.Metadata.Rom.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_Rom_WithoutHashesWithoutSize()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("item");
|
||||
rom.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
rom.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(rom, statsOnly: false);
|
||||
|
||||
DatItem actual = Assert.Single(dict.GetItemsForBucket("default"));
|
||||
Assert.True(actual is Rom);
|
||||
Assert.Equal(0, actual.GetInt64FieldValue(Data.Models.Metadata.Rom.SizeKey));
|
||||
Assert.Equal(HashType.SHA1.ZeroString, actual.GetStringFieldValue(Data.Models.Metadata.Rom.SHA1Key));
|
||||
Assert.Equal("none", actual.GetStringFieldValue(Data.Models.Metadata.Rom.StatusKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_StatsOnly()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetName("item");
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: true);
|
||||
|
||||
Assert.Empty(dict.GetItemsForBucket("default"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddItem_NormalAdd()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
Machine machine = new Machine();
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetName("item");
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: false);
|
||||
|
||||
Assert.Single(dict.GetItemsForBucket("default"));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region ClearMarked
|
||||
|
||||
[Fact]
|
||||
public void ClearMarkedTest()
|
||||
{
|
||||
// Setup the items
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("game-1");
|
||||
|
||||
DatItem rom1 = new Rom();
|
||||
rom1.SetName("rom-1");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine);
|
||||
|
||||
DatItem rom2 = new Rom();
|
||||
rom2.SetName("rom-2");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
rom2.SetFieldValue<bool?>(DatItem.RemoveKey, true);
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom2.CopyMachineInformation(machine);
|
||||
|
||||
// Setup the dictionary
|
||||
var dict = new ItemDictionary();
|
||||
dict.AddItem(rom1, statsOnly: false);
|
||||
dict.AddItem(rom2, statsOnly: false);
|
||||
|
||||
dict.ClearMarked();
|
||||
Assert.Empty(dict.GetItemsForBucket("default"));
|
||||
List<DatItem> items = dict.GetItemsForBucket("game-1");
|
||||
Assert.Single(items);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region GetItemsForBucket
|
||||
|
||||
[Fact]
|
||||
public void GetItemsForBucket_NullBucketName()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: false);
|
||||
|
||||
var actual = dict.GetItemsForBucket(null, filter: false);
|
||||
|
||||
Assert.Empty(actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetItemsForBucket_InvalidBucketName()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: false);
|
||||
|
||||
var actual = dict.GetItemsForBucket("INVALID", filter: false);
|
||||
|
||||
Assert.Empty(actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetItemsForBucket_RemovedFilter()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetFieldValue<bool?>(DatItem.RemoveKey, true);
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: false);
|
||||
|
||||
var actual = dict.GetItemsForBucket("machine", filter: true);
|
||||
|
||||
Assert.Empty(actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetItemsForBucket_RemovedNoFilter()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetFieldValue<bool?>(DatItem.RemoveKey, true);
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: false);
|
||||
|
||||
var actual = dict.GetItemsForBucket("machine", filter: false);
|
||||
|
||||
Assert.Single(actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetItemsForBucket_Standard()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: false);
|
||||
|
||||
var actual = dict.GetItemsForBucket("machine", filter: false);
|
||||
|
||||
Assert.Single(actual);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region RemoveBucket
|
||||
|
||||
[Fact]
|
||||
public void RemoveBucketTest()
|
||||
{
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("game-1");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetName("rom-1");
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
datItem.CopyMachineInformation(machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
dict.AddItem(datItem, statsOnly: false);
|
||||
|
||||
dict.RemoveBucket("game-1");
|
||||
|
||||
Assert.Empty(dict.GetItemsForBucket("default"));
|
||||
Assert.Empty(dict.GetItemsForBucket("game-1"));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region RemoveItem
|
||||
|
||||
[Fact]
|
||||
public void RemoveItemTest()
|
||||
{
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("game-1");
|
||||
|
||||
DatItem datItem = new Rom();
|
||||
datItem.SetName("rom-1");
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
datItem.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
datItem.CopyMachineInformation(machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
dict.AddItem(datItem, statsOnly: false);
|
||||
|
||||
dict.RemoveItem("game-1", (Rom)datItem.Clone(), 0);
|
||||
|
||||
Assert.Empty(dict.GetItemsForBucket("default"));
|
||||
Assert.Empty(dict.GetItemsForBucket("game-1"));
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region BucketBy
|
||||
|
||||
[Theory]
|
||||
[InlineData(ItemKey.NULL, 2)]
|
||||
[InlineData(ItemKey.Machine, 2)]
|
||||
[InlineData(ItemKey.CRC, 1)]
|
||||
[InlineData(ItemKey.SHA1, 4)]
|
||||
public void BucketByTest(ItemKey itemKey, int expected)
|
||||
{
|
||||
// Setup the items
|
||||
Machine machine1 = new Machine();
|
||||
machine1.SetName("game-1");
|
||||
|
||||
Machine machine2 = new Machine();
|
||||
machine2.SetName("game-2");
|
||||
|
||||
DatItem rom1 = new Rom();
|
||||
rom1.SetName("rom-1");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine1);
|
||||
|
||||
DatItem rom2 = new Rom();
|
||||
rom2.SetName("rom-2");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine1);
|
||||
|
||||
DatItem rom3 = new Rom();
|
||||
rom3.SetName("rom-3");
|
||||
rom3.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
rom3.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "00000ea4014ce66679e7e17d56ac510f67e39e26");
|
||||
rom3.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine2);
|
||||
|
||||
DatItem rom4 = new Rom();
|
||||
rom4.SetName("rom-4");
|
||||
rom4.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "DEAEEF");
|
||||
rom4.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "00000151d437442e74e5134023fab8bf694a2487");
|
||||
rom4.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine2);
|
||||
|
||||
// Setup the dictionary
|
||||
var dict = new ItemDictionary();
|
||||
dict.AddItem(rom1, statsOnly: false);
|
||||
dict.AddItem(rom2, statsOnly: false);
|
||||
dict.AddItem(rom3, statsOnly: false);
|
||||
dict.AddItem(rom4, statsOnly: false);
|
||||
|
||||
dict.BucketBy(itemKey);
|
||||
Assert.Equal(expected, dict.SortedKeys.Length);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Deduplicate
|
||||
|
||||
[Fact]
|
||||
public void DeduplicateTest()
|
||||
{
|
||||
// Setup the items
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("game-1");
|
||||
|
||||
DatItem rom1 = new Rom();
|
||||
rom1.SetName("rom-1");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine);
|
||||
|
||||
DatItem rom2 = new Rom();
|
||||
rom2.SetName("rom-2");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom2.CopyMachineInformation(machine);
|
||||
|
||||
// Setup the dictionary
|
||||
var dict = new ItemDictionary();
|
||||
dict.AddItem(rom1, statsOnly: false);
|
||||
dict.AddItem(rom2, statsOnly: false);
|
||||
|
||||
dict.Deduplicate();
|
||||
Assert.Equal(1, dict.DatStatistics.TotalCount);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region GetDuplicateStatus
|
||||
|
||||
[Fact]
|
||||
public void GetDuplicateStatus_NullOther_NoDupe()
|
||||
{
|
||||
var dict = new ItemDictionary();
|
||||
DatItem item = new Rom();
|
||||
DatItem? lastItem = null;
|
||||
var actual = dict.GetDuplicateStatus(item, lastItem);
|
||||
Assert.Equal((DupeType)0x00, actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetDuplicateStatus_DifferentTypes_NoDupe()
|
||||
{
|
||||
var dict = new ItemDictionary();
|
||||
var rom = new Rom();
|
||||
DatItem? lastItem = new Disk();
|
||||
var actual = dict.GetDuplicateStatus(rom, lastItem);
|
||||
Assert.Equal((DupeType)0x00, actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetDuplicateStatus_MismatchedHashes_NoDupe()
|
||||
{
|
||||
var dict = new ItemDictionary();
|
||||
|
||||
Machine? machineA = new Machine();
|
||||
machineA.SetName("name-same");
|
||||
|
||||
Machine? machineB = new Machine();
|
||||
machineB.SetName("name-same");
|
||||
|
||||
var romA = new Rom();
|
||||
romA.SetName("same-name");
|
||||
romA.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "BEEFDEAD");
|
||||
romA.SetFieldValue<Source?>(DatItem.SourceKey, new Source(0));
|
||||
romA.CopyMachineInformation(machineA);
|
||||
|
||||
var romB = new Rom();
|
||||
romB.SetName("same-name");
|
||||
romB.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romB.SetFieldValue<Source?>(DatItem.SourceKey, new Source(1));
|
||||
romB.CopyMachineInformation(machineB);
|
||||
|
||||
var actual = dict.GetDuplicateStatus(romA, romB);
|
||||
Assert.Equal((DupeType)0x00, actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetDuplicateStatus_DifferentSource_NameMatch_ExternalAll()
|
||||
{
|
||||
var dict = new ItemDictionary();
|
||||
|
||||
Machine? machineA = new Machine();
|
||||
machineA.SetName("name-same");
|
||||
|
||||
Machine? machineB = new Machine();
|
||||
machineB.SetName("name-same");
|
||||
|
||||
var romA = new Rom();
|
||||
romA.SetName("same-name");
|
||||
romA.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romA.SetFieldValue<Source?>(DatItem.SourceKey, new Source(0));
|
||||
romA.CopyMachineInformation(machineA);
|
||||
|
||||
var romB = new Rom();
|
||||
romB.SetName("same-name");
|
||||
romB.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romB.SetFieldValue<Source?>(DatItem.SourceKey, new Source(1));
|
||||
romB.CopyMachineInformation(machineB);
|
||||
|
||||
var actual = dict.GetDuplicateStatus(romA, romB);
|
||||
Assert.Equal(DupeType.External | DupeType.All, actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetDuplicateStatus_DifferentSource_NoNameMatch_ExternalHash()
|
||||
{
|
||||
var dict = new ItemDictionary();
|
||||
|
||||
Machine? machineA = new Machine();
|
||||
machineA.SetName("name-same");
|
||||
|
||||
Machine? machineB = new Machine();
|
||||
machineB.SetName("not-name-same");
|
||||
|
||||
var romA = new Rom();
|
||||
romA.SetName("same-name");
|
||||
romA.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romA.SetFieldValue<Source?>(DatItem.SourceKey, new Source(0));
|
||||
romA.CopyMachineInformation(machineA);
|
||||
|
||||
var romB = new Rom();
|
||||
romB.SetName("same-name");
|
||||
romB.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romB.SetFieldValue<Source?>(DatItem.SourceKey, new Source(1));
|
||||
romB.CopyMachineInformation(machineB);
|
||||
|
||||
var actual = dict.GetDuplicateStatus(romA, romB);
|
||||
Assert.Equal(DupeType.External | DupeType.Hash, actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetDuplicateStatus_SameSource_NameMatch_InternalAll()
|
||||
{
|
||||
var dict = new ItemDictionary();
|
||||
|
||||
Machine? machineA = new Machine();
|
||||
machineA.SetName("name-same");
|
||||
|
||||
Machine? machineB = new Machine();
|
||||
machineB.SetName("name-same");
|
||||
|
||||
var romA = new Rom();
|
||||
romA.SetName("same-name");
|
||||
romA.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romA.SetFieldValue<Source?>(DatItem.SourceKey, new Source(0));
|
||||
romA.CopyMachineInformation(machineA);
|
||||
|
||||
var romB = new Rom();
|
||||
romB.SetName("same-name");
|
||||
romB.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romB.SetFieldValue<Source?>(DatItem.SourceKey, new Source(0));
|
||||
romB.CopyMachineInformation(machineB);
|
||||
|
||||
var actual = dict.GetDuplicateStatus(romA, romB);
|
||||
Assert.Equal(DupeType.Internal | DupeType.All, actual);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetDuplicateStatus_SameSource_NoNameMatch_InternalHash()
|
||||
{
|
||||
var dict = new ItemDictionary();
|
||||
|
||||
Machine? machineA = new Machine();
|
||||
machineA.SetName("name-same");
|
||||
|
||||
Machine? machineB = new Machine();
|
||||
machineB.SetName("not-name-same");
|
||||
|
||||
var romA = new Rom();
|
||||
romA.SetName("same-name");
|
||||
romA.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romA.SetFieldValue<Source?>(DatItem.SourceKey, new Source(0));
|
||||
romA.CopyMachineInformation(machineA);
|
||||
|
||||
var romB = new Rom();
|
||||
romB.SetName("same-name");
|
||||
romB.SetFieldValue(Data.Models.Metadata.Rom.CRCKey, "DEADBEEF");
|
||||
romB.SetFieldValue<Source?>(DatItem.SourceKey, new Source(0));
|
||||
romB.CopyMachineInformation(machineB);
|
||||
|
||||
var actual = dict.GetDuplicateStatus(romA, romB);
|
||||
Assert.Equal(DupeType.Internal | DupeType.Hash, actual);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region GetDuplicates
|
||||
|
||||
[Theory]
|
||||
[InlineData(true, 1)]
|
||||
[InlineData(false, 0)]
|
||||
public void GetDuplicatesTest(bool hasDuplicate, int expected)
|
||||
{
|
||||
// Setup the items
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("game-1");
|
||||
|
||||
DatItem rom1 = new Rom();
|
||||
rom1.SetName("rom-1");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine);
|
||||
|
||||
DatItem rom2 = new Rom();
|
||||
rom2.SetName("rom-2");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom2.CopyMachineInformation(machine);
|
||||
|
||||
// Setup the dictionary
|
||||
var dict = new ItemDictionary();
|
||||
dict.AddItem(rom1, statsOnly: false);
|
||||
dict.AddItem(rom2, statsOnly: false);
|
||||
|
||||
// Setup the test item
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("rom-1");
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, hasDuplicate ? "1024" : "2048");
|
||||
rom.CopyMachineInformation(machine);
|
||||
|
||||
var actual = dict.GetDuplicates(rom);
|
||||
Assert.Equal(expected, actual.Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region HasDuplicates
|
||||
|
||||
[Theory]
|
||||
[InlineData(true)]
|
||||
[InlineData(false)]
|
||||
public void HasDuplicatesTest(bool expected)
|
||||
{
|
||||
// Setup the items
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("game-1");
|
||||
|
||||
DatItem rom1 = new Rom();
|
||||
rom1.SetName("rom-1");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom1.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine);
|
||||
|
||||
DatItem rom2 = new Rom();
|
||||
rom2.SetName("rom-2");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
|
||||
rom2.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, "1024");
|
||||
rom1.CopyMachineInformation(machine);
|
||||
|
||||
// Setup the dictionary
|
||||
var dict = new ItemDictionary();
|
||||
dict.AddItem("game-1", rom1);
|
||||
dict.AddItem("game-1", rom2);
|
||||
|
||||
// Setup the test item
|
||||
DatItem rom = new Rom();
|
||||
rom.SetName("rom-1");
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
|
||||
rom.SetFieldValue<string?>(Data.Models.Metadata.Rom.SizeKey, expected ? "1024" : "2048");
|
||||
rom1.CopyMachineInformation(machine);
|
||||
|
||||
bool actual = dict.HasDuplicates(rom);
|
||||
Assert.Equal(expected, actual);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region RecalculateStats
|
||||
|
||||
[Fact]
|
||||
public void RecalculateStatsTest()
|
||||
{
|
||||
Source source = new Source(0, source: null);
|
||||
|
||||
Machine machine = new Machine();
|
||||
machine.SetName("machine");
|
||||
|
||||
DatItem item = new Rom();
|
||||
item.SetName("rom");
|
||||
item.SetFieldValue<long?>(Data.Models.Metadata.Rom.SizeKey, 12345);
|
||||
item.SetFieldValue<string?>(Data.Models.Metadata.Rom.CRCKey, "deadbeef");
|
||||
item.SetFieldValue<Source?>(DatItem.SourceKey, source);
|
||||
item.SetFieldValue<Machine?>(DatItem.MachineKey, machine);
|
||||
|
||||
var dict = new ItemDictionary();
|
||||
_ = dict.AddItem(item, statsOnly: false);
|
||||
|
||||
Assert.Equal(1, dict.DatStatistics.TotalCount);
|
||||
Assert.Equal(1, dict.DatStatistics.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(12345, dict.DatStatistics.TotalSize);
|
||||
Assert.Equal(1, dict.DatStatistics.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(0, dict.DatStatistics.GetHashCount(HashType.MD5));
|
||||
|
||||
item.SetFieldValue<string?>(Data.Models.Metadata.Rom.MD5Key, "deadbeef");
|
||||
|
||||
dict.RecalculateStats();
|
||||
|
||||
Assert.Equal(1, dict.DatStatistics.TotalCount);
|
||||
Assert.Equal(1, dict.DatStatistics.GetItemCount(ItemType.Rom));
|
||||
Assert.Equal(12345, dict.DatStatistics.TotalSize);
|
||||
Assert.Equal(1, dict.DatStatistics.GetHashCount(HashType.CRC32));
|
||||
Assert.Equal(1, dict.DatStatistics.GetHashCount(HashType.MD5));
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
|
||||
<IsPackable>false</IsPackable>
|
||||
<LangVersion>latest</LangVersion>
|
||||
<Nullable>enable</Nullable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="coverlet.collector" Version="8.0.1" />
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
|
||||
<PackageReference Include="SabreTools.Hashing" Version="[2.0.0]" />
|
||||
<PackageReference Include="xunit" Version="2.9.3" />
|
||||
<PackageReference Include="xunit.runner.visualstudio" Version="3.1.5" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\SabreTools.Metadata\SabreTools.Metadata.csproj" />
|
||||
<ProjectReference Include="..\SabreTools.Metadata.DatFiles\SabreTools.Metadata.DatFiles.csproj" />
|
||||
<ProjectReference Include="..\SabreTools.Metadata.DatItems\SabreTools.Metadata.DatItems.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
Reference in New Issue
Block a user