fixup! test: shared contracts of the map modules, run for HashMap and IMap

The tests of the computation expression get a row for `yield!` of a null array of struct pairs and
of a null hash map, which must throw `ArgumentNullException` that names `pairs` or `table` when the
expression runs the member.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

Author: xperiandri

tests/FSharp.Collections.Immutable.Tests/HashMap/HashMapComputationExpressionTests.fs

@@ -105,10 +105,30 @@ type HashMapComputationExpressionTests () =
                         |> ignore)
         |]
 
+    /// The expressions that take an array or a hash map, by name, with the name of the parameter and the expression on a null
+    /// one. A null array or hash map is not a sequence for the member, which would fail with NullReferenceException when
+    /// the buffer runs; the expression rejects it when the member runs.
+    static let nullCollectionExpressions : Map<string, struct (string * (unit -> unit))> =
+        Map.ofArray [|
+            "yield! of an array of struct pairs",
+            struct ("pairs",
+                    fun () ->
+                        hashMap { yield! Unchecked.defaultof<struct (int * string) array> }
+                        |> ignore)
+            "yield! of a hash map",
+            struct ("table",
+                    fun () ->
+                        hashMap { yield! Unchecked.defaultof<HashMap<int, string>> }
+                        |> ignore)
+        |]
+
     /// The names of the members that set a binding, as the rows of the test of the values that the default comparer finds
     /// equal.
     static member EqualValueExpressions = equalValueExpressions.Keys
 
+    /// The names of the expressions that take an array or a hash map and are given a null one, as the rows of their test.
+    static member NullCollectionExpressions = nullCollectionExpressions.Keys
+
     /// The names of the expressions that take a sequence and are given a null one, as the rows of their test.
     static member NullSequenceExpressions = nullSequenceExpressions.Keys
 
@@ -324,6 +344,11 @@ type HashMapComputationExpressionTests () =
         let struct (paramName, run) = nullSequenceExpressions[name]
         FlatListAssert.RejectsNull ($"hashMap %s{name}", paramName, run)
 
+    [<TestMethod; DynamicData(nameof HashMapComputationExpressionTests.NullCollectionExpressions)>]
+    member _.``yield! rejects a null array and a null hash map`` (name : string) =
+        let struct (paramName, run) = nullCollectionExpressions[name]
+        FlatListAssert.RejectsNull ($"hashMap %s{name}", paramName, run)
+
     [<TestMethod; DynamicData(nameof HashMapComputationExpressionTests.DefaultSequenceExpressions)>]
     member _.``yield! and for reject a default flat list given as a sequence`` (name : string) =
         // The member rejects it as the functions of HashMap do, when the expression runs it and not when the buffer does