Write ResolveNames/DB tests

2025-12-16 19:14:27 +00:00 · 2025-01-10 10:30:49 -05:00
parent 3155e7d03c
commit c8a927e75f
2 changed files with 331 additions and 18 deletions
--- a/SabreTools.DatFiles.Test/DatFileTests.cs
+++ b/SabreTools.DatFiles.Test/DatFileTests.cs
@@ -1548,23 +1548,336 @@ namespace SabreTools.DatFiles.Test

        #region ResolveNames

-        // TODO: Write ResolveNames tests
-        // - Empty list
-        // - Single item
-        // - 2 items, non-duplicate
-        // - 2 items, DupeType.All
-        // - 2 items, matching names
+        [Fact]
+        public void ResolveNames_EmptyList_Empty()
+        {
+            List<DatItem> datItems = [];
+
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<DatItem> actual = datFile.ResolveNames(datItems);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void ResolveNames_SingleItem_Single()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("name");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<DatItem> datItems = [romA];
+
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<DatItem> actual = datFile.ResolveNames(datItems);
+            DatItem actualItemA = Assert.Single(actual);
+            Rom? actualRomA = actualItemA as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("name", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }
+
+        [Fact]
+        public void ResolveNames_NonDuplicate_AllUntouched()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("romA");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            Rom romB = new Rom();
+            romB.SetName("romB");
+            romB.SetFieldValue(Models.Metadata.Rom.SizeKey, 23456);
+            romB.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc2");
+            romB.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romB.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<DatItem> datItems = [romA, romB];
+
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<DatItem> actual = datFile.ResolveNames(datItems);
+            Assert.Equal(2, actual.Count);
+
+            Rom? actualRomA = actual[0] as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("romA", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+
+            Rom? actualRomB = actual[1] as Rom;
+            Assert.NotNull(actualRomB);
+            Assert.Equal("romB", actualRomB.GetName());
+            Assert.Equal(23456, actualRomB.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc2", actualRomB.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }
+
+        [Fact]
+        public void ResolveNames_AllDuplicate_Single()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("rom");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            Rom romB = new Rom();
+            romB.SetName("rom");
+            romB.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romB.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romB.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romB.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<DatItem> datItems = [romA, romB];
+
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<DatItem> actual = datFile.ResolveNames(datItems);
+            DatItem actualItemA = Assert.Single(actual);
+            Rom? actualRomA = actualItemA as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("rom", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }
+
+        [Fact]
+        public void ResolveNames_NameMatch_SingleRenamed()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("rom");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            Rom romB = new Rom();
+            romB.SetName("rom");
+            romB.SetFieldValue(Models.Metadata.Rom.SizeKey, 23456);
+            romB.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc2");
+            romB.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romB.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<DatItem> datItems = [romA, romB];
+
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<DatItem> actual = datFile.ResolveNames(datItems);
+            Assert.Equal(2, actual.Count);
+
+            Rom? actualRomA = actual[0] as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("rom", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+
+            Rom? actualRomB = actual[1] as Rom;
+            Assert.NotNull(actualRomB);
+            Assert.Equal("rom_crc2", actualRomB.GetName());
+            Assert.Equal(23456, actualRomB.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc2", actualRomB.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }

        #endregion

        #region ResolveNamesDB

-        // TODO: Write ResolveNamesDB tests
-        // - Empty list
-        // - Single item
-        // - 2 items, non-duplicate
-        // - 2 items, DupeType.All
-        // - 2 items, matching names
+        [Fact]
+        public void ResolveNamesDB_EmptyList_Empty()
+        {
+            List<KeyValuePair<long, DatItem>> mappings = [];
+
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<KeyValuePair<long, DatItem>> actual = datFile.ResolveNamesDB(mappings);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void ResolveNamesDB_SingleItem_Single()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("name");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<KeyValuePair<long, DatItem>> mappings =
+            [
+                new KeyValuePair<long, DatItem>(0, romA),
+            ];
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<KeyValuePair<long, DatItem>> actual = datFile.ResolveNamesDB(mappings);
+            KeyValuePair<long, DatItem> actualItemA = Assert.Single(actual);
+            Rom? actualRomA = actualItemA.Value as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("name", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }
+
+        [Fact]
+        public void ResolveNamesDB_NonDuplicate_AllUntouched()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("romA");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            Rom romB = new Rom();
+            romB.SetName("romB");
+            romB.SetFieldValue(Models.Metadata.Rom.SizeKey, 23456);
+            romB.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc2");
+            romB.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romB.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<KeyValuePair<long, DatItem>> mappings =
+            [
+                new KeyValuePair<long, DatItem>(0, romA),
+                new KeyValuePair<long, DatItem>(1, romB),
+            ];
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<KeyValuePair<long, DatItem>> actual = datFile.ResolveNamesDB(mappings);
+            Assert.Equal(2, actual.Count);
+
+            Rom? actualRomA = actual[0].Value as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("romA", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+
+            Rom? actualRomB = actual[1].Value as Rom;
+            Assert.NotNull(actualRomB);
+            Assert.Equal("romB", actualRomB.GetName());
+            Assert.Equal(23456, actualRomB.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc2", actualRomB.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }
+
+        [Fact]
+        public void ResolveNamesDB_AllDuplicate_Single()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("rom");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            Rom romB = new Rom();
+            romB.SetName("rom");
+            romB.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romB.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romB.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romB.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<KeyValuePair<long, DatItem>> mappings =
+            [
+                new KeyValuePair<long, DatItem>(0, romA),
+                new KeyValuePair<long, DatItem>(1, romB),
+            ];
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<KeyValuePair<long, DatItem>> actual = datFile.ResolveNamesDB(mappings);
+            KeyValuePair<long, DatItem> actualItemA = Assert.Single(actual);
+            Rom? actualRomA = actualItemA.Value as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("rom", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }
+
+        [Fact]
+        public void ResolveNamesDB_NameMatch_SingleRenamed()
+        {
+            Machine machine = new Machine();
+            machine.SetFieldValue(Models.Metadata.Machine.NameKey, "machine");
+
+            Source source = new Source(0);
+
+            Rom romA = new Rom();
+            romA.SetName("rom");
+            romA.SetFieldValue(Models.Metadata.Rom.SizeKey, 12345);
+            romA.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc");
+            romA.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romA.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            Rom romB = new Rom();
+            romB.SetName("rom");
+            romB.SetFieldValue(Models.Metadata.Rom.SizeKey, 23456);
+            romB.SetFieldValue(Models.Metadata.Rom.CRCKey, "crc2");
+            romB.SetFieldValue(DatItem.MachineKey, (Machine)machine.Clone());
+            romB.SetFieldValue(DatItem.SourceKey, (Source)source.Clone());
+
+            List<KeyValuePair<long, DatItem>> mappings =
+            [
+                new KeyValuePair<long, DatItem>(0, romA),
+                new KeyValuePair<long, DatItem>(1, romB),
+            ];
+            DatFile datFile = new Formats.Logiqx(null, deprecated: false);
+
+            List<KeyValuePair<long, DatItem>> actual = datFile.ResolveNamesDB(mappings);
+            Assert.Equal(2, actual.Count);
+
+            Rom? actualRomA = actual[0].Value as Rom;
+            Assert.NotNull(actualRomA);
+            Assert.Equal("rom", actualRomA.GetName());
+            Assert.Equal(12345, actualRomA.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc", actualRomA.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+
+            Rom? actualRomB = actual[1].Value as Rom;
+            Assert.NotNull(actualRomB);
+            Assert.Equal("rom_crc2", actualRomB.GetName());
+            Assert.Equal(23456, actualRomB.GetInt64FieldValue(Models.Metadata.Rom.SizeKey));
+            Assert.Equal("crc2", actualRomB.GetStringFieldValue(Models.Metadata.Rom.CRCKey));
+        }

        #endregion

--- a/SabreTools.DatFiles/DatFile.cs
+++ b/SabreTools.DatFiles/DatFile.cs
@@ -454,27 +454,27 @@ namespace SabreTools.DatFiles
        /// <summary>
        /// Resolve name duplicates in an arbitrary set of DatItems based on the supplied information
        /// </summary>
-        /// <param name="items">List of DatItem objects representing the items to be merged</param>
+        /// <param name="datItems">List of DatItem objects representing the items to be merged</param>
        /// <returns>A List of DatItem objects representing the renamed items</returns>
-        protected internal List<DatItem> ResolveNames(List<DatItem> items)
+        protected internal List<DatItem> ResolveNames(List<DatItem> datItems)
        {
            // Ignore empty lists
-            if (items.Count == 0)
+            if (datItems.Count == 0)
                return [];

            // Create the output list
            List<DatItem> output = [];

            // First we want to make sure the list is in alphabetical order
-            DatFileTool.Sort(ref items, true);
+            DatFileTool.Sort(ref datItems, true);

            // Now we want to loop through and check names
            DatItem? lastItem = null;
            string? lastrenamed = null;
            int lastid = 0;
-            for (int i = 0; i < items.Count; i++)
+            for (int i = 0; i < datItems.Count; i++)
            {
-                DatItem datItem = items[i];
+                DatItem datItem = datItems[i];

                // If we have the first item, we automatically add it
                if (lastItem == null)