Permit DictionaryContainsKeyValuePairConstraint to take in a null val…

…ue (fix CS8604) (#4689)

* Permit DictionaryContainsKeyValuePairConstraint to take in a null value, matching the nullability of DictionaryEntry.

* Fix up nullability of DictionaryContainsValueConstraint to permit `object?` instead of `object`.

* Add some basic tests that null values can be found in dictionaries by DictionaryContains(Key)ValueConstraint.

* Update DictionaryContainsKeyValueConstraintTests.cs to use [TestCase] instead of [Theory].

* Update DictionaryContainsValueConstraintTests.cs to replace use of [Theory] with [TestCase].

---------

Co-authored-by: Andrew McClement <andrew.mcclement@aveva.com>

src/NUnitFramework/framework/Constraints/ConstraintExpression.cs

@@ -734,7 +734,7 @@ public DictionaryContainsKeyConstraint ContainKey(object expected)
         /// presence of a particular value in the Dictionary value collection.
         /// </summary>
         /// <param name="expected">The value to be matched in the Dictionary value collection</param>
-        public DictionaryContainsValueConstraint ContainValue(object expected)
+        public DictionaryContainsValueConstraint ContainValue(object? expected)
         {
             return Append(new DictionaryContainsValueConstraint(expected));
         }

src/NUnitFramework/framework/Constraints/DictionaryContainsKeyConstraint.cs

@@ -51,9 +51,9 @@ public DictionaryContainsKeyConstraint(object expected)
         /// Returns a new DictionaryContainsKeyValuePairConstraint checking for the
         /// presence of a particular key-value-pair in the dictionary.
         /// </summary>
-        public DictionaryContainsKeyValuePairConstraint WithValue(object expectedValue)
+        public DictionaryContainsKeyValuePairConstraint WithValue(object? expectedValue)
         {
-            return (DictionaryContainsKeyValuePairConstraint)Instead.Append(new DictionaryContainsKeyValuePairConstraint(Expected, expectedValue));
+            return Instead.Append(new DictionaryContainsKeyValuePairConstraint(Expected, expectedValue));
         }
 
         private bool Matches(object? actual)

src/NUnitFramework/framework/Constraints/DictionaryContainsKeyValuePairConstraint.cs

@@ -19,7 +19,7 @@ public sealed class DictionaryContainsKeyValuePairConstraint : CollectionItemsEq
         /// <summary>
         /// Construct a DictionaryContainsKeyValuePairConstraint
         /// </summary>
-        public DictionaryContainsKeyValuePairConstraint(object key, object value)
+        public DictionaryContainsKeyValuePairConstraint(object key, object? value)
         {
             _expected = new DictionaryEntry(key, value);
         }

src/NUnitFramework/framework/Contains.cs

@@ -41,7 +41,7 @@ public static DictionaryContainsKeyConstraint Key(object expected)
         /// Returns a new DictionaryContainsValueConstraint checking for the
         /// presence of a particular value in the dictionary.
         /// </summary>
-        public static DictionaryContainsValueConstraint Value(object expected)
+        public static DictionaryContainsValueConstraint Value(object? expected)
         {
             return new DictionaryContainsValueConstraint(expected);
         }

src/NUnitFramework/framework/Does.cs

@@ -71,7 +71,7 @@ public static DictionaryContainsKeyConstraint ContainKey(object expected)
         /// presence of a particular value in the Dictionary value collection.
         /// </summary>
         /// <param name="expected">The value to be matched in the Dictionary value collection</param>
-        public static DictionaryContainsValueConstraint ContainValue(object expected)
+        public static DictionaryContainsValueConstraint ContainValue(object? expected)
         {
             return Contains.Value(expected);
         }

src/NUnitFramework/tests/Constraints/DictionaryContainsKeyValueConstraintTests.cs

@@ -10,12 +10,13 @@ namespace NUnit.Framework.Tests.Constraints
     [TestFixture]
     public class DictionaryContainsKeyValuePairConstraintTests
     {
-        [Test]
-        public void SucceedsWhenKeyValuePairIsPresent()
+        [TestCase("Universe")]
+        [TestCase(null)]
+        public void SucceedsWhenKeyValuePairIsPresent(string? expectedValue)
         {
-            var dictionary = new Dictionary<string, string> { { "Hello", "World" }, { "Hi", "Universe" }, { "Hola", "Mundo" } };
+            var dictionary = new Dictionary<string, string?> { { "Hello", "World" }, { "Hi", expectedValue }, { "Hola", "Mundo" } };
 
-            Assert.That(dictionary, new DictionaryContainsKeyValuePairConstraint("Hi", "Universe"));
+            Assert.That(dictionary, new DictionaryContainsKeyValuePairConstraint("Hi", expectedValue));
         }
 
         [Test]
@@ -38,11 +39,12 @@ public void FailsWhenValueIsMissing()
             Assert.That(act, Throws.Exception.TypeOf<AssertionException>());
         }
 
-        [Test]
-        public void SucceedsWhenPairIsPresentUsingContainKeyWithValue()
+        [TestCase("Mundo")]
+        [TestCase(null)]
+        public void SucceedsWhenPairIsPresentUsingContainKeyWithValue(string? expectedValue)
         {
-            var dictionary = new Dictionary<string, string> { { "Hello", "World" }, { "Hola", "Mundo" } };
-            Assert.That(dictionary, Does.ContainKey("Hola").WithValue("Mundo"));
+            var dictionary = new Dictionary<string, string?> { { "Hello", "World" }, { "Hola", expectedValue } };
+            Assert.That(dictionary, Does.ContainKey("Hola").WithValue(expectedValue));
         }
 
         [Test]

src/NUnitFramework/tests/Constraints/DictionaryContainsValueConstraintTests.cs

@@ -28,11 +28,12 @@ public void FailsWhenValueIsMissing()
             Assert.That(act, Throws.Exception.TypeOf<AssertionException>());
         }
 
-        [Test]
-        public void SucceedsWhenValueIsPresentUsingContainValue()
+        [TestCase("Mundo")]
+        [TestCase(null)]
+        public void SucceedsWhenValueIsPresentUsingContainValue(string? expectedValue)
         {
-            var dictionary = new Dictionary<string, string> { { "Hello", "World" }, { "Hola", "Mundo" } };
-            Assert.That(dictionary, Does.ContainValue("Mundo"));
+            var dictionary = new Dictionary<string, string?> { { "Hello", "World" }, { "Hola", expectedValue } };
+            Assert.That(dictionary, Does.ContainValue(expectedValue));
         }
 
         [Test]