Port existing item dict tests, add DB variants

SabreTools.DatFiles.Test/ItemDictionaryDBTests.cs

@@ -0,0 +1,276 @@
+using System.Collections.Generic;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+using Xunit;
+
+namespace SabreTools.DatFiles.Test
+{
+    public class ItemDictionaryDBTests
+    {
+        #region AddItem
+
+        // TODO: Add AddItem tests
+
+        #endregion
+
+        #region AddMachine
+
+        // TODO: Add AddMachine tests
+
+        #endregion
+
+        #region AddSource
+
+        // TODO: Add AddSource tests
+
+        #endregion
+
+        #region ClearMarked
+
+        [Fact]
+        public void ClearMarkedTest()
+        {
+            // Setup the items
+            Source source = new Source(0, source: null);
+
+            Machine machine = new Machine();
+            machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
+
+            DatItem rom1 = new Rom();
+            rom1.SetName("rom-1");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            DatItem rom2 = new Rom();
+            rom2.SetName("rom-2");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom2.SetFieldValue<bool?>(DatItem.RemoveKey, true);
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            // Setup the dictionary
+            var dict = new ItemDictionaryDB();
+            long sourceIndex = dict.AddSource(source);
+            long machineIndex = dict.AddMachine(machine);
+            dict.AddItem(rom1, machineIndex, sourceIndex, statsOnly: false);
+            dict.AddItem(rom2, machineIndex, sourceIndex, statsOnly: false);
+
+            dict.ClearMarked();
+            string key = Assert.Single(dict.SortedKeys);
+            Assert.Equal("game-1", key);
+            Dictionary<long, DatItem> items = dict.GetItemsForBucket(key);
+            Assert.Single(items);
+        }
+
+        #endregion
+
+        #region GetItemsForBucket
+
+        // TODO: Add GetItemsForBucket tests
+
+        #endregion
+
+        #region GetMachine
+
+        // TODO: Add GetMachine tests
+
+        #endregion
+
+        #region GetMachineForItem
+
+        // TODO: Add GetMachineForItem tests
+
+        #endregion
+
+        #region GetSource
+
+        // TODO: Add GetSource tests
+
+        #endregion
+
+        #region GetSourceForItem
+
+        // TODO: Add GetSourceForItem tests
+
+        #endregion
+
+        #region RemapDatItemToMachine
+
+        // TODO: Add RemapDatItemToMachine tests
+
+        #endregion
+
+        #region RemoveBucket
+
+        // TODO: Add RemoveBucket tests
+
+        #endregion
+
+        #region RemoveItem
+
+        // TODO: Add RemoveItem tests
+
+        #endregion
+
+        #region SetBucketedBy
+
+        // TODO: Add SetBucketedBy tests
+
+        #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
+            Source source = new Source(0, source: null);
+
+            Machine machine1 = new Machine();
+            machine1.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
+
+            Machine machine2 = new Machine();
+            machine2.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-2");
+
+            DatItem rom1 = new Rom();
+            rom1.SetName("rom-1");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            DatItem rom2 = new Rom();
+            rom2.SetName("rom-2");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            DatItem rom3 = new Rom();
+            rom3.SetName("rom-3");
+            rom3.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom3.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "00000ea4014ce66679e7e17d56ac510f67e39e26");
+            rom3.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            DatItem rom4 = new Rom();
+            rom4.SetName("rom-4");
+            rom4.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom4.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "00000151d437442e74e5134023fab8bf694a2487");
+            rom4.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            // Setup the dictionary
+            var dict = new ItemDictionaryDB();
+            long sourceIndex = dict.AddSource(source);
+            long machine1Index = dict.AddMachine(machine1);
+            long machine2Index = dict.AddMachine(machine2);
+            dict.AddItem(rom1, machine1Index, sourceIndex, statsOnly: false);
+            dict.AddItem(rom2, machine1Index, sourceIndex, statsOnly: false);
+            dict.AddItem(rom3, machine2Index, sourceIndex, statsOnly: false);
+            dict.AddItem(rom4, machine2Index, sourceIndex, statsOnly: false);
+
+            dict.BucketBy(itemKey);
+            Assert.Equal(expected, dict.SortedKeys.Length);
+        }
+
+        #endregion
+
+        #region Deduplicate
+
+        // TODO: Add Deduplicate tests
+
+        #endregion
+
+        #region GetDuplicates
+
+        [Theory]
+        [InlineData(true, 1)]
+        [InlineData(false, 0)]
+        public void GetDuplicatesTest(bool hasDuplicate, int expected)
+        {
+            // Setup the items
+            Source source = new Source(0, source: null);
+
+            Machine machine = new Machine();
+            machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
+
+            DatItem rom1 = new Rom();
+            rom1.SetName("rom-1");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            DatItem rom2 = new Rom();
+            rom2.SetName("rom-2");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            // Setup the dictionary
+            var dict = new ItemDictionaryDB();
+            long sourceIndex = dict.AddSource(source);
+            long machineIndex = dict.AddMachine(machine);
+            dict.AddItem(rom1, machineIndex, sourceIndex, statsOnly: false);
+            dict.AddItem(rom2, machineIndex, sourceIndex, statsOnly: false);
+
+            // Setup the test item
+            DatItem rom = new Rom();
+            rom.SetName("rom-1");
+            rom.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
+            rom.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, hasDuplicate ? "1024" : "2048");
+
+            var actual = dict.GetDuplicates(new KeyValuePair<long, DatItem>(-1, rom));
+            Assert.Equal(expected, actual.Count);
+        }
+
+        #endregion
+
+        #region HasDuplicates
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void HasDuplicatesTest(bool expected)
+        {
+            // Setup the items
+            Source source = new Source(0, source: null);
+
+            Machine machine = new Machine();
+            machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
+
+            DatItem rom1 = new Rom();
+            rom1.SetName("rom-1");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            DatItem rom2 = new Rom();
+            rom2.SetName("rom-2");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+
+            // Setup the dictionary
+            var dict = new ItemDictionaryDB();
+            long sourceIndex = dict.AddSource(source);
+            long machineIndex = dict.AddMachine(machine);
+            dict.AddItem(rom1, machineIndex, sourceIndex, statsOnly: false);
+            dict.AddItem(rom2, machineIndex, sourceIndex, statsOnly: false);
+
+            // Setup the test item
+            DatItem rom = new Rom();
+            rom.SetName("rom-1");
+            rom.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
+            rom.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, expected ? "1024" : "2048");
+
+            bool actual = dict.HasDuplicates(new KeyValuePair<long, DatItem>(-1, rom));
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region RecalculateStats
+
+        // TODO: Add RecalculateStats tests
+
+        #endregion
+    }
+}

SabreTools.DatFiles.Test/ItemDictionaryTests.cs

@@ -1,13 +1,81 @@
 using System.Collections.Generic;
-using SabreTools.DatFiles;
 using SabreTools.DatItems;
 using SabreTools.DatItems.Formats;
 using Xunit;
 
-namespace SabreTools.Test.DatFiles
+namespace SabreTools.DatFiles.Test
 {
     public class ItemDictionaryTests
     {
+        #region AddItem
+
+        // TODO: Add AddItem tests
+
+        #endregion
+
+        #region ClearMarked
+
+        [Fact]
+        public void ClearMarkedTest()
+        {
+            // Setup the items
+            Machine machine = new Machine();
+            machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
+
+            DatItem rom1 = new Rom();
+            rom1.SetName("rom-1");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
+            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+            rom1.CopyMachineInformation(machine);
+
+            DatItem rom2 = new Rom();
+            rom2.SetName("rom-2");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
+            rom2.SetFieldValue<bool?>(DatItem.RemoveKey, true);
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
+            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
+            rom1.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
+
+        // TODO: Add GetItemsForBucket tests
+
+        #endregion
+
+        #region RemoveBucket
+
+        // TODO: Add RemoveBucket tests
+
+        #endregion
+
+        #region RemoveItem
+
+        // TODO: Add RemoveItem tests
+
+        #endregion
+
+        #region RemoveMachine
+
+        // TODO: Add RemoveMachine tests
+
+        #endregion
+
+        #region BucketBy
+
         [Theory]
         [InlineData(ItemKey.NULL, 2)]
         [InlineData(ItemKey.Machine, 2)]
@@ -16,34 +84,34 @@ namespace SabreTools.Test.DatFiles
         public void BucketByTest(ItemKey itemKey, int expected)
         {
             // Setup the items
-            var machine1 = new Machine();
+            Machine machine1 = new Machine();
             machine1.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
 
-            var machine2 = new Machine();
+            Machine machine2 = new Machine();
             machine2.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-2");
 
-            var rom1 = new Rom();
+            DatItem rom1 = new Rom();
             rom1.SetName("rom-1");
             rom1.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
             rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
             rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
             rom1.CopyMachineInformation(machine1);
 
-            var rom2 = new Rom();
+            DatItem rom2 = new Rom();
             rom2.SetName("rom-2");
             rom2.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
             rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
             rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
             rom1.CopyMachineInformation(machine1);
 
-            var rom3 = new Rom();
+            DatItem rom3 = new Rom();
             rom3.SetName("rom-3");
             rom3.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
             rom3.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "00000ea4014ce66679e7e17d56ac510f67e39e26");
             rom3.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
             rom1.CopyMachineInformation(machine2);
 
-            var rom4 = new Rom();
+            DatItem rom4 = new Rom();
             rom4.SetName("rom-4");
             rom4.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
             rom4.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "00000151d437442e74e5134023fab8bf694a2487");
@@ -61,39 +129,15 @@ namespace SabreTools.Test.DatFiles
             Assert.Equal(expected, dict.SortedKeys.Length);
         }
 
-        [Fact]
+        #endregion
-        public void ClearMarkedTest()
-        {
-            // Setup the items
-            var machine1 = new Machine();
-            machine1.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
 
-            var rom1 = new Rom();
+        #region Deduplicate
-            rom1.SetName("rom-1");
-            rom1.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
-            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
-            rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
-            rom1.CopyMachineInformation(machine1);
 
-            var rom2 = new Rom();
+        // TODO: Add Deduplicate tests
-            rom2.SetName("rom-2");
-            rom2.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, "DEADBEEF");
-            rom2.SetFieldValue<bool?>(DatItem.RemoveKey, true);
-            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
-            rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
-            rom1.CopyMachineInformation(machine1);
 
-            // Setup the dictionary
+        #endregion
-            var dict = new ItemDictionary();
-            dict.AddItem("game-1", rom1);
-            dict.AddItem("game-1", rom2);
 
-            dict.ClearMarked();
+        #region GetDuplicates
-            string key = Assert.Single(dict.SortedKeys);
-            Assert.Equal("game-1", key);
-            List<DatItem> items = dict.GetItemsForBucket(key);
-            Assert.Single(items);
-        }
 
         [Theory]
         [InlineData(true, 1)]
@@ -101,57 +145,61 @@ namespace SabreTools.Test.DatFiles
         public void GetDuplicatesTest(bool hasDuplicate, int expected)
         {
             // Setup the items
-            var machine1 = new Machine();
+            Machine machine = new Machine();
-            machine1.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
+            machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
 
-            var rom1 = new Rom();
+            DatItem rom1 = new Rom();
             rom1.SetName("rom-1");
             rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
             rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
-            rom1.CopyMachineInformation(machine1);
+            rom1.CopyMachineInformation(machine);
 
-            var rom2 = new Rom();
+            DatItem rom2 = new Rom();
             rom2.SetName("rom-2");
             rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
             rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
-            rom1.CopyMachineInformation(machine1);
+            rom1.CopyMachineInformation(machine);
 
             // Setup the dictionary
             var dict = new ItemDictionary();
-            dict.AddItem("game-1", rom1);
+            dict.AddItem(rom1, statsOnly: false);
-            dict.AddItem("game-1", rom2);
+            dict.AddItem(rom2, statsOnly: false);
 
             // Setup the test item
-            var rom = new Rom();
+            DatItem rom = new Rom();
             rom.SetName("rom-1");
             rom.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
             rom.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, hasDuplicate ? "1024" : "2048");
-            rom1.CopyMachineInformation(machine1);
+            rom1.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
-            var machine1 = new Machine();
+            Machine machine = new Machine();
-            machine1.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
+            machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, "game-1");
 
-            var rom1 = new Rom();
+            DatItem rom1 = new Rom();
             rom1.SetName("rom-1");
             rom1.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
             rom1.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
-            rom1.CopyMachineInformation(machine1);
+            rom1.CopyMachineInformation(machine);
 
-            var rom2 = new Rom();
+            DatItem rom2 = new Rom();
             rom2.SetName("rom-2");
             rom2.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "000000e948edcb4f7704b8af85a77a3339ecce44");
             rom2.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, "1024");
-            rom1.CopyMachineInformation(machine1);
+            rom1.CopyMachineInformation(machine);
 
             // Setup the dictionary
             var dict = new ItemDictionary();
@@ -159,23 +207,22 @@ namespace SabreTools.Test.DatFiles
             dict.AddItem("game-1", rom2);
 
             // Setup the test item
-            var rom = new Rom();
+            DatItem rom = new Rom();
             rom.SetName("rom-1");
             rom.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, "0000000fbbb37f8488100b1b4697012de631a5e6");
             rom.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, expected ? "1024" : "2048");
-            rom1.CopyMachineInformation(machine1);
+            rom1.CopyMachineInformation(machine);
 
             bool actual = dict.HasDuplicates(rom);
             Assert.Equal(expected, actual);
         }
 
-        [Fact]
+        #endregion
-        public void ResetStatisticsTest()
+    
-        {
+        #region RecalculateStats
-            var dict = new ItemDictionary();
+
-            dict.DatStatistics.GameCount = 1;
+        // TODO: Add RecalculateStats tests
-            dict.DatStatistics.ResetStatistics();
+
-            Assert.Equal(0, dict.DatStatistics.GameCount);
+        #endregion
-        }
     }
 }

SabreTools.DatFiles/ItemDictionary.cs

@@ -210,21 +210,6 @@ namespace SabreTools.DatFiles
             }
         }
 
-        /// <summary>
-        /// Ensure the key exists in the items dictionary
-        /// </summary>
-        /// <param name="key">Key to ensure</param>
-        public void EnsureBucketingKey(string key)
-        {
-            // If the key is missing from the dictionary, add it
-#if NET40_OR_GREATER || NETCOREAPP
-            _items.GetOrAdd(key, []);
-#else
-            if (!_items.ContainsKey(key))
-                _items[key] = [];
-#endif
-        }
-
         /// <summary>
         /// Get the items associated with a bucket name
         /// </summary>
@@ -485,7 +470,22 @@ namespace SabreTools.DatFiles
             if (roms.Count == 0)
                 return false;
 
-            return roms.FindIndex(r => datItem.Equals(r)) > -1;
+            return roms.FindIndex(datItem.Equals) > -1;
+        }
+
+        /// <summary>
+        /// Ensure the key exists in the items dictionary
+        /// </summary>
+        /// <param name="key">Key to ensure</param>
+        private void EnsureBucketingKey(string key)
+        {
+            // If the key is missing from the dictionary, add it
+#if NET40_OR_GREATER || NETCOREAPP
+            _items.GetOrAdd(key, []);
+#else
+            if (!_items.ContainsKey(key))
+                _items[key] = [];
+#endif
         }
 
         /// <summary>

SabreTools.DatFiles/ItemDictionaryDB.cs

@@ -705,8 +705,9 @@ namespace SabreTools.DatFiles
             if (DatStatistics.TotalCount == 0)
                 return [];
 
-            // We want to get the proper key for the DatItem
+            // We want to get the proper key for the DatItem, ignoring the index
-            string key = SortAndGetKey(datItem, sorted);
+            _ = SortAndGetKey(datItem, sorted);
+            string key = datItem.Value.GetKey(_bucketedBy);
 
             // If the key doesn't exist, return the empty list
             var items = GetItemsForBucket(key);
@@ -745,8 +746,9 @@ namespace SabreTools.DatFiles
             if (DatStatistics.TotalCount == 0)
                 return false;
 
-            // We want to get the proper key for the DatItem
+            // We want to get the proper key for the DatItem, ignoring the index
-            string key = SortAndGetKey(datItem, sorted);
+            _ = SortAndGetKey(datItem, sorted);
+            string key = datItem.Value.GetKey(_bucketedBy);
 
             // If the key doesn't exist
             var roms = GetItemsForBucket(key);
@@ -754,7 +756,7 @@ namespace SabreTools.DatFiles
                 return false;
 
             // Try to find duplicates
-            return roms.Values.Any(r => datItem.Equals(r));
+            return roms.Values.Any(datItem.Value.Equals);
         }
 
         /// <summary>
@@ -859,6 +861,20 @@ namespace SabreTools.DatFiles
             return output;
         }
 
+        /// <summary>
+        /// Ensure the key exists in the items dictionary
+        /// </summary>
+        private void EnsureBucketingKey(string key)
+        {
+            // If the key is missing from the dictionary, add it
+#if NET40_OR_GREATER || NETCOREAPP
+            _buckets.GetOrAdd(key, []);
+#else
+            if (!_buckets.ContainsKey(key))
+                _buckets[key] = [];
+#endif
+        }
+
         /// <summary>
         /// Get the highest-order Field value that represents the statistics
         /// </summary>
@@ -935,20 +951,6 @@ namespace SabreTools.DatFiles
             return datItem.GetKeyDB(bucketBy, machine.Value, source.Value, lower, norename);
         }
 
-        /// <summary>
-        /// Ensure the key exists in the items dictionary
-        /// </summary>
-        private void EnsureBucketingKey(string key)
-        {
-            // If the key is missing from the dictionary, add it
-#if NET40_OR_GREATER || NETCOREAPP
-            _buckets.GetOrAdd(key, []);
-#else
-            if (!_buckets.ContainsKey(key))
-                _buckets[key] = [];
-#endif
-        }
-
         /// <summary>
         /// Perform bucketing based on the item key provided
         /// </summary>