fixup! test: shared contracts of the set modules, run for HashSet and ISet

Pin the recipe that the changelog gives for passing a sequence to a relation or to an
operation of the set algebra, which take sets, not sequences, in `HashSet` and `ISet`. The
strings, the comparers and the sets and sequences of each case are in `SetRelationInputs`,
which the two test classes share:

- 24 rows each: the six relations and `intersect` and `symmetricDifference`, with the
  default comparer, a comparer that ignores case and a reference comparer
  (`HashIdentity.Reference`) as the comparer of the first set. The strings are two instances
  of "a", "A" and "b". The conversion with the comparer of the first set,
  `(HashSet.forComparer (HashSet.comparer set)).ofSeq` for `HashSet` and
  `ISet.addRange elements (ISet.clear set)` for `ISet`, answers as the member of the BCL type
  (of the interface for `ISet`) in every row. The conversion with the default comparer,
  `HashSet.ofSeq`, answers as the member for the first two comparers, which find equal what
  the default comparer finds equal, and differently for the reference comparer, which tells
  the two instances of "a" apart where the default comparer keeps one of them.
- 6 rows each: `overlaps` and `isSuperset` as `Seq.exists` and `Seq.forall` with `contains`
  answer as the members with all three comparers.

Each pinned behavior was broken once in the code, 11 mutations (`ofSeq` of the struct
converting with the default comparer, `isSubset` of each module comparing in the comparer of
the second set, `contains` of each module comparing in the default comparer, `intersect` and
`symmetricDifference` of each module converting the second set with the default comparer,
`ISet.clear` without the comparer, and the reference comparer of the test data comparing by
the default comparer), and a new test failed each time.

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

Author: xperiandri

tests/FSharp.Collections.Immutable.Tests/Contracts/SetInputs.fs

@@ -1,5 +1,6 @@
 namespace FSharp.Collections.Immutable.Tests
 
+open System
 open System.Collections.Generic
 
 /// <summary>
@@ -109,3 +110,105 @@ type SetInputs =
 
     /// The comparer of the structs that create sorted sets: it orders numbers by their remainders.
     static member ByRemainder = byRemainder
+
+/// <summary>
+/// The inputs of the tests that pass a sequence to a relation or to an operation of the set algebra. The functions of the
+/// set modules take sets, where the members of the BCL types take sequences, so a sequence is converted to a set first
+/// (ADR 0001, D14).
+/// </summary>
+/// <remarks>
+/// <para>
+/// A test builds the first set from the strings of a relation with one of the comparers, builds the sequence from the
+/// other strings, and compares the answer of the member of the BCL type for the sequence with the answer of the function of
+/// the module for the set that the sequence is converted to.
+/// </para>
+/// <para>
+/// The strings tell the comparers apart: when the first set compares by reference, each relation and each operation answers
+/// differently for the sequence that the default comparer converts, which keeps one of "a1" and "a2", than for the sequence
+/// that the comparer of the first set converts.
+/// </para>
+/// </remarks>
+[<AbstractClass; Sealed>]
+type SetRelationInputs =
+
+    /// <summary>
+    /// The strings by name: "a1" and "a2" have the text "a" and are different instances, "A" differs from them in case, and
+    /// "b" has other text.
+    /// </summary>
+    /// <remarks>
+    /// The instances are created once: a comparer by reference tells "a1" from "a2", so the first set and the sequence of a
+    /// test must hold the same two instances.
+    /// </remarks>
+    static let pool : Map<string, string> =
+        Map.ofArray [| "a1", String [| 'a' |]; "a2", String [| 'a' |]; "A", "A"; "b", "b" |]
+
+    /// <summary>
+    /// The comparers of the first set, by name, each with whether it finds equal every pair of strings that the default
+    /// comparer finds equal.
+    /// </summary>
+    static let comparers : Map<string, struct (IEqualityComparer<string> * bool)> =
+        Map.ofArray [|
+            "default comparer", struct (EqualityComparer<string>.Default :> IEqualityComparer<string>, true)
+            "comparer that ignores case", struct (StringComparer.OrdinalIgnoreCase :> IEqualityComparer<string>, true)
+            // It tells "a1" from "a2", which the default comparer finds equal
+            "reference comparer", struct (HashIdentity.Reference, false)
+        |]
+
+    /// <summary>
+    /// The names of the strings of the first set and of the sequence of each relation, by the name of the relation.
+    /// </summary>
+    static let items : Map<string, struct (string array * string array)> =
+        Map.ofArray [|
+            "isProperSubset", struct ([| "a1"; "a2" |], [| "a1"; "a2"; "b" |])
+            "isProperSuperset", struct ([| "a1"; "a2"; "A" |], [| "a1"; "a2"; "A" |])
+            "isSubset", struct ([| "a1"; "a2"; "A" |], [| "a1"; "a2"; "A" |])
+            "isSuperset", struct ([| "a1" |], [| "a1"; "a2" |])
+            // The default comparer keeps "a2", the first string of the sequence
+            "overlaps", struct ([| "a1" |], [| "a2"; "a1" |])
+            "setEquals", struct ([| "a1"; "a2"; "A" |], [| "a1"; "a2"; "A" |])
+        |]
+
+    /// <summary>
+    /// The names of the strings of the first set and of the sequence of each operation of the set algebra that takes a
+    /// sequence in the BCL types and returns a set, by the name of the operation.
+    /// </summary>
+    static let operationItems : Map<string, struct (string array * string array)> =
+        Map.ofArray [|
+            "intersect", struct ([| "a1"; "a2" |], [| "a1"; "a2" |])
+            "symmetricDifference", struct ([| "a1"; "a2" |], [| "a1"; "a2" |])
+        |]
+
+    /// The strings for their names in the pool.
+    static member Strings (names : string array) = names |> Array.map (fun name -> pool[name])
+
+    /// The names of the strings of the first set and of the sequence of each relation, by the name of the relation.
+    static member Items = items
+
+    /// The comparers of the first set, by name, each with whether it finds equal every pair of strings that the default
+    /// comparer finds equal.
+    static member Comparers = comparers
+
+    /// The relations of a set with a sequence, each with every comparer of the first set, as rows.
+    static member Rows = seq {
+        for relation in items.Keys do
+            for comparer in comparers.Keys do
+                struct (relation, comparer)
+    }
+
+    /// The relations that need no conversion, each with every comparer of the first set, as rows.
+    static member StreamingRows = seq {
+        for relation in [ "isSuperset"; "overlaps" ] do
+            for comparer in comparers.Keys do
+                struct (relation, comparer)
+    }
+
+    /// The names of the strings of the first set and of the sequence of each operation of the set algebra, by the name of
+    /// the operation.
+    static member OperationItems = operationItems
+
+    /// The operations of the set algebra with a sequence, each with every comparer of the first set, as rows.
+    static member OperationRows = seq {
+        for operation in operationItems.Keys do
+            for comparer in comparers.Keys do
+                struct (operation, comparer)
+    }

tests/FSharp.Collections.Immutable.Tests/HashSet/HashSetTests.fs

@@ -238,6 +238,45 @@ type HashSetTests () =
             struct ("elements", (fun () -> ints.ofSeq defaultElements |> ignore))
         |]
 
+    /// <summary>
+    /// The relations of a hash set with a sequence, by name: the member of the BCL type, which takes the sequence, and the
+    /// function of the module, which takes a hash set.
+    /// </summary>
+    static let relationFunctions
+        : Map<string, struct ((HashSet<string> -> seq<string> -> bool) * (HashSet<string> -> HashSet<string> -> bool))> =
+        Map.ofArray [|
+            nameof HashSet.isProperSubset, struct ((fun set elements -> set.IsProperSubsetOf elements), HashSet.isProperSubset)
+            nameof HashSet.isProperSuperset,
+            struct ((fun set elements -> set.IsProperSupersetOf elements), HashSet.isProperSuperset)
+            nameof HashSet.isSubset, struct ((fun set elements -> set.IsSubsetOf elements), HashSet.isSubset)
+            nameof HashSet.isSuperset, struct ((fun set elements -> set.IsSupersetOf elements), HashSet.isSuperset)
+            nameof HashSet.overlaps, struct ((fun set elements -> set.Overlaps elements), HashSet.overlaps)
+            nameof HashSet.setEquals, struct ((fun set elements -> set.SetEquals elements), HashSet.setEquals)
+        |]
+
+    /// <summary>
+    /// The operations of the set algebra with a sequence, by name: the member of the BCL type, which takes the sequence, and
+    /// the function of the module, which takes a hash set.
+    /// </summary>
+    static let operationFunctions
+        : Map<
+              string,
+              struct ((HashSet<string> -> seq<string> -> HashSet<string>) *
+              (HashSet<string> -> HashSet<string> -> HashSet<string>))
+           > =
+        Map.ofArray [|
+            nameof HashSet.intersect, struct ((fun set elements -> set.Intersect elements), HashSet.intersect)
+            nameof HashSet.symmetricDifference,
+            struct ((fun set elements -> set.SymmetricExcept elements), HashSet.symmetricDifference)
+        |]
+
+    /// The relations that need no conversion, by name, as the changelog gives them: each tests the elements with contains.
+    static let streamingRecipes : Map<string, HashSet<string> -> seq<string> -> bool> =
+        Map.ofArray [|
+            nameof HashSet.isSuperset, (fun set elements -> Seq.forall (fun item -> HashSet.contains item set) elements)
+            nameof HashSet.overlaps, (fun set elements -> Seq.exists (fun item -> HashSet.contains item set) elements)
+        |]
+
     /// The names of the creation functions without a comparer, as rows.
     static member DefaultCreations = defaultCreations.Keys
 
@@ -555,6 +594,97 @@ type HashSetTests () =
             "HashSet.contains must compare with the default comparer"
         )
 
+    // ---- Relations with a sequence ----
+
+    // The way to pass a sequence to a relation, as the changelog gives it: convert the sequence with the comparer of the
+    // first set. The default comparer gives the same answer when the comparer of the first set finds equal what the default
+    // comparer finds equal, and another answer when it tells such strings apart, as the reference comparer does
+    [<TestMethod; DynamicData(nameof SetRelationInputs.Rows, typeof<SetRelationInputs>)>]
+    member _.``a relation with a sequence takes the sequence that the comparer of the first set converts``
+        (relation : string, comparer : string)
+        =
+        let instances = SetRelationInputs.Strings [| "a1"; "a2" |]
+        Assert.AreNotSame (
+            instances[0],
+            instances[1],
+            "The test needs two strings with the same text that are different instances"
+        )
+
+        let struct (setItems, sequenceItems) = SetRelationInputs.Items[relation]
+        let struct (bclMember, moduleFunction) = relationFunctions[relation]
+        let struct (firstComparer, defaultFindsEqualWhatItFindsEqual) = SetRelationInputs.Comparers[comparer]
+        let set = (HashSet.forComparer firstComparer).ofArray(SetRelationInputs.Strings setItems)
+        let elements = SetRelationInputs.Strings sequenceItems
+        let expected = bclMember set elements
+
+        Assert.AreEqual<bool>(
+            expected,
+            moduleFunction set ((HashSet.forComparer (HashSet.comparer set)).ofSeq elements),
+            $"HashSet.%s{relation} must answer as the member of the BCL type for the sequence that the comparer of the first set converts"
+        )
+
+        let withDefaultComparer = moduleFunction set (HashSet.ofSeq elements)
+
+        if defaultFindsEqualWhatItFindsEqual then
+            Assert.AreEqual<bool>(
+                expected,
+                withDefaultComparer,
+                $"HashSet.%s{relation} must answer as the member of the BCL type for the sequence that the default comparer converts, because the comparer of the first set finds equal what the default comparer finds equal"
+            )
+        else
+            Assert.AreNotEqual<bool>(
+                expected,
+                withDefaultComparer,
+                $"HashSet.%s{relation} must answer differently for the sequence that the default comparer converts, because the comparer of the first set tells apart strings that the default comparer finds equal"
+            )
+
+    // The same recipe for the operations of the set algebra that take a sequence in the BCL type
+    [<TestMethod; DynamicData(nameof SetRelationInputs.OperationRows, typeof<SetRelationInputs>)>]
+    member _.``an operation with a sequence takes the sequence that the comparer of the first set converts``
+        (operation : string, comparer : string)
+        =
+        let struct (setItems, sequenceItems) = SetRelationInputs.OperationItems[operation]
+        let struct (bclMember, moduleFunction) = operationFunctions[operation]
+        let struct (firstComparer, defaultFindsEqualWhatItFindsEqual) = SetRelationInputs.Comparers[comparer]
+        let set = (HashSet.forComparer firstComparer).ofArray(SetRelationInputs.Strings setItems)
+        let elements = SetRelationInputs.Strings sequenceItems
+        let expected = HashSet.toArray (bclMember set elements)
+
+        CollectionAssert.AreEquivalent (
+            expected,
+            HashSet.toArray (moduleFunction set ((HashSet.forComparer (HashSet.comparer set)).ofSeq elements)),
+            $"HashSet.%s{operation} must return the result of the member of the BCL type for the sequence that the comparer of the first set converts"
+        )
+
+        let withDefaultComparer = HashSet.toArray (moduleFunction set (HashSet.ofSeq elements))
+
+        if defaultFindsEqualWhatItFindsEqual then
+            CollectionAssert.AreEquivalent (
+                expected,
+                withDefaultComparer,
+                $"HashSet.%s{operation} must return the result of the member of the BCL type for the sequence that the default comparer converts, because the comparer of the first set finds equal what the default comparer finds equal"
+            )
+        else
+            CollectionAssert.AreNotEquivalent (
+                expected,
+                withDefaultComparer,
+                $"HashSet.%s{operation} must return another result for the sequence that the default comparer converts, because the comparer of the first set tells apart strings that the default comparer finds equal"
+            )
+
+    [<TestMethod; DynamicData(nameof SetRelationInputs.StreamingRows, typeof<SetRelationInputs>)>]
+    member _.``overlaps and isSuperset with a sequence test each element with contains`` (relation : string, comparer : string) =
+        let struct (setItems, sequenceItems) = SetRelationInputs.Items[relation]
+        let struct (bclMember, _) = relationFunctions[relation]
+        let struct (firstComparer, _) = SetRelationInputs.Comparers[comparer]
+        let set = (HashSet.forComparer firstComparer).ofArray(SetRelationInputs.Strings setItems)
+        let elements = SetRelationInputs.Strings sequenceItems
+
+        Assert.AreEqual<bool>(
+            bclMember set elements,
+            streamingRecipes[relation] set elements,
+            $"%s{relation} with a sequence must test each element with HashSet.contains, in the comparer of the first set"
+        )
+
     // ---- Null inputs ----
 
     [<TestMethod; DynamicData(nameof HashSetTests.NullRejections)>]