fix: value comparer usage, remove by key/value pair, indexer assignment

# Conflicts:
#	src/BidirectionalDictionary/BidirectionalDictionary.csproj

Author: iikuzmychov

src/BidirectionalDictionary/BidirectionalDictionary.cs

@@ -55,6 +55,7 @@ public class BidirectionalDictionary<TKey, TValue> : IBidirectionalDictionary<TK
     /// <param name="key">The key of the value to get or set.</param>
     /// <returns>The value associated with the specified key. If the specified key is not found, a get operation throws a
     /// <see cref="KeyNotFoundException"/>, and a set operation creates a new element with the specified key.</returns>
+    /// <remarks>The stored key instance is preserved; the inverse view mirrors it.</remarks>
     /// <exception cref="ArgumentNullException"></exception>
     /// <exception cref="ArgumentException"></exception>
     /// <exception cref="KeyNotFoundException"></exception>
@@ -71,20 +72,15 @@ public TValue this[TKey key]
 
             if (TryGetValue(key, out var oldValue))
             {
-                if (ValueComparer.Equals(oldValue, value))
-                    return;
-
-                if (ContainsValue(value))
+                if (!ValueComparer.Equals(oldValue, value) && ContainsValue(value))
                 {
                     throw new ArgumentException("The value already exists.", nameof(value));
                 }
-                else
-                {
-                    _baseDictionary[key] = value;
 
-                    Inverse._baseDictionary.Remove(oldValue);
-                    Inverse._baseDictionary.Add(value, key);
-                }
+                var storedKey = Inverse._baseDictionary[oldValue];
+                _baseDictionary[key] = value;
+                Inverse._baseDictionary.Remove(oldValue);
+                Inverse._baseDictionary.Add(value, storedKey);
             }
             else
             {
@@ -412,8 +408,12 @@ bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> i
         if (item.Value == null)
             throw new ArgumentNullException("The item value == null.", nameof(item));
 
-        return ((ICollection<KeyValuePair<TKey, TValue>>)_baseDictionary).Remove(item) &&
-            Inverse._baseDictionary.Remove(item.Value);
+        if (!_baseDictionary.TryGetValue(item.Key, out var value) || !ValueComparer.Equals(value, item.Value))
+        {
+            return false;
+        }
+
+        return Remove(item.Key);
     }
 
     bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
@@ -424,7 +424,7 @@ bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue>
         if (item.Value == null)
             throw new ArgumentNullException("The item value == null.", nameof(item));
 
-        return ((ICollection<KeyValuePair<TKey, TValue>>)_baseDictionary).Contains(item);
+        return _baseDictionary.TryGetValue(item.Key, out var value) && ValueComparer.Equals(value, item.Value);
     }
 
     void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) =>

src/BidirectionalDictionary/BidirectionalDictionary.csproj

@@ -15,7 +15,7 @@
     <PackageProjectUrl>https://github.com/iiKuzmychov/BidirectionalDictionary</PackageProjectUrl>
     <RepositoryUrl>https://github.com/iiKuzmychov/BidirectionalDictionary</RepositoryUrl>
     <PackageTags>bidirectional-dictionary;bidirectional;bidirect;bidictionary;bimap;two-way;dictionary;map;readonly;read-only</PackageTags>
-    <Version>1.4.1</Version>
+    <Version>1.4.2</Version>
     <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 

tests/BidirectionalDictionary.Tests/BidirectionalDictionaryTests.ICollection{KeyValuePair{TKey,TValue}}.cs

@@ -179,4 +179,86 @@ public void ICollectionKeyValuePair_Contains_FilledBiDictionaryAndPairWithNullKe
 
         Assert.Throws<ArgumentNullException>(() => ((ICollection<KeyValuePair<char?, int?>>)biDictionary).Contains(pair));
     }
+
+    [Fact]
+    [Trait("Method", "ICollection<KeyValuePair<TKey, TValue>>")]
+    public void ICollectionKeyValuePair_Contains_CustomValueComparer_UsesValueComparer()
+    {
+        var biDictionary = new BidirectionalDictionary<string, string>(
+            keyComparer: null,
+            valueComparer: StringComparer.OrdinalIgnoreCase)
+        {
+            { "x", "abc" },
+        };
+
+        var collection = (ICollection<KeyValuePair<string, string>>)biDictionary;
+
+        Assert.True(collection.Contains(new KeyValuePair<string, string>("x", "ABC")));
+        Assert.True(collection.Contains(new KeyValuePair<string, string>("x", "abc")));
+        Assert.False(collection.Contains(new KeyValuePair<string, string>("x", "xyz")));
+    }
+
+    [Fact]
+    [Trait("Method", "ICollection<KeyValuePair<TKey, TValue>>")]
+    public void ICollectionKeyValuePair_Contains_ReferenceEqualityValueComparer_DistinguishesInstances()
+    {
+        var s1 = new string("abc".ToCharArray());
+        var s2 = new string("abc".ToCharArray());
+
+        var biDictionary = new BidirectionalDictionary<int, string>(
+            keyComparer: null,
+            valueComparer: ReferenceEqualityComparer.Instance)
+        {
+            { 1, s1 },
+        };
+
+        var collection = (ICollection<KeyValuePair<int, string>>)biDictionary;
+
+        Assert.True(collection.Contains(new KeyValuePair<int, string>(1, s1)));
+        Assert.False(collection.Contains(new KeyValuePair<int, string>(1, s2)));
+    }
+
+    [Fact]
+    [Trait("Method", "ICollection<KeyValuePair<TKey, TValue>>")]
+    public void ICollectionKeyValuePair_Remove_ReferenceEqualityValueComparer_DoesNotDesyncMaps()
+    {
+        var s1 = new string("abc".ToCharArray());
+        var s2 = new string("abc".ToCharArray());
+
+        var biDictionary = new BidirectionalDictionary<int, string>(
+            keyComparer: null,
+            valueComparer: ReferenceEqualityComparer.Instance)
+        {
+            { 1, s1 },
+        };
+
+        var collection = (ICollection<KeyValuePair<int, string>>)biDictionary;
+
+        var isRemoved = collection.Remove(new KeyValuePair<int, string>(1, s2));
+
+        Assert.False(isRemoved);
+        Assert.Single(biDictionary, new KeyValuePair<int, string>(1, s1));
+        Assert.Single(biDictionary.Inverse.Keys, s1);
+        Assert.Equal(biDictionary.Count, biDictionary.Inverse.Count);
+    }
+
+    [Fact]
+    [Trait("Method", "ICollection<KeyValuePair<TKey, TValue>>")]
+    public void ICollectionKeyValuePair_Remove_CustomValueComparerMatchingPair_RemovesFromBothMaps()
+    {
+        var biDictionary = new BidirectionalDictionary<string, string>(
+            keyComparer: null,
+            valueComparer: StringComparer.OrdinalIgnoreCase)
+        {
+            { "x", "abc" },
+        };
+
+        var collection = (ICollection<KeyValuePair<string, string>>)biDictionary;
+
+        var isRemoved = collection.Remove(new KeyValuePair<string, string>("x", "ABC"));
+
+        Assert.True(isRemoved);
+        Assert.Empty(biDictionary);
+        Assert.Empty(biDictionary.Inverse);
+    }
 }

tests/BidirectionalDictionary.Tests/BidirectionalDictionaryTests.cs

@@ -699,5 +699,40 @@ public void Indexer_Set_EmptyBiDictionaryAndMissingKeyAndNonDuplicateValue_Creat
         Assert.Single(biDictionary.Inverse.Values, 'a');
     }
 
+    [Fact]
+    public void Indexer_Set_ExistingKeyAndComparerEqualValue_ReplacesStoredValueInstance()
+    {
+        var biDictionary = new BidirectionalDictionary<string, string>(
+            keyComparer: null,
+            valueComparer: StringComparer.OrdinalIgnoreCase)
+        {
+            { "x", "abc" },
+        };
+
+        biDictionary["x"] = "ABC";
+
+        Assert.Equal("ABC", biDictionary["x"]);
+        Assert.Single(biDictionary.Values, "ABC");
+        Assert.Single(biDictionary.Inverse.Keys, "ABC");
+        Assert.Equal("x", biDictionary.Inverse["ABC"]);
+    }
+
+    [Fact]
+    public void Indexer_Set_ComparerEqualKey_PreservesStoredKeyInstanceOnBothSides()
+    {
+        var storedKey = "x";
+        var biDictionary = new BidirectionalDictionary<string, int>(
+            keyComparer: StringComparer.OrdinalIgnoreCase,
+            valueComparer: null)
+        {
+            { storedKey, 1 },
+        };
+
+        biDictionary["X"] = 2;
+
+        Assert.Same(storedKey, biDictionary.Keys.Single());
+        Assert.Same(storedKey, biDictionary.Inverse[2]);
+    }
+
     #endregion
 }