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

Tests of the gaps of the sets report (package A4), 2843 per target framework:

- `SetMutationOps` gets `AddRange`, `RemoveRange` and `OfSeqByRemainder`, and
  `SetCreationOps` and `SetCustomComparerOps` get `OfReadOnlySpan` and `OfSpan`, one
  field for each function. `SortedSet` derives the tests of the mutation and creation
  contracts with these fields.
- `SetMutationContract` runs `addRange` and `removeRange` with an array, a list and a lazy
  sequence over every pair of inputs, against `Set.union` and `Set.difference`, and with a
  comparer by remainder, where the elements of the set stay and the first of the other
  elements of each remainder is added (D14). The input itself must come back when the
  sequence adds nothing or removes nothing, under both comparers, and a null sequence
  throws `ArgumentNullException` with the name `elements`.
- `SetCreationContract` runs `ofReadOnlySpan` and `ofSpan` of the module and of the struct on
  a copy of each input that the test changes after the call. `SetInputs` gets the row
  sources of the pairs that add or remove nothing, and `Remainders`, which `SetContract`
  uses too.
- `HashSetTests` pins the first of the equal elements of a span through the table of the
  struct, `addRange` of an empty hash set (`Union` answers it with another instance), the
  comparer of an empty input that receives a hash set with another comparer, and `ofSeq` of
  the struct for an equal but distinct comparer instance. The tables of the comparer, the
  creation functions and the null checks list the new functions. `HashSetBuilderTests`
  covers `build`, the `build` of the struct and `update`, and `ISetTests` the
  implementation and the comparer kept by `addRange` and `removeRange`.

Each new behavior was broken once in the code, 25 mutations, and a test failed each time.

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

Author: xperiandri

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

@@ -62,9 +62,6 @@ type SetContract<'S> (ops : SetOps<'S>) =
     /// A folder from the end whose state records the order in which it saw the elements.
     static let recordBack (item : int) (visited : int array) = Array.append visited [| item |]
 
-    /// The remainders of the elements of an input in the division by 5, as a set that compares by remainders sees them.
-    static let remainders (input : int array) = Set.ofArray (Array.map SetInputs.Remainder input)
-
     /// <summary>
     /// The sets of a pair of inputs for the relations under the comparer of the first set.
     /// </summary>
@@ -263,7 +260,7 @@ type SetContract<'S> (ops : SetOps<'S>) =
         let struct (set1, set2) = createByRemainder first second
 
         Assert.AreEqual<bool>(
-            Set.isProperSubset (remainders first) (remainders second),
+            Set.isProperSubset (SetInputs.Remainders first) (SetInputs.Remainders second),
             ops.IsProperSubset set1 set2,
             $"%s{ops.Name}.isProperSubset must count the elements that the comparer of the first set finds equal once"
         )
@@ -273,7 +270,7 @@ type SetContract<'S> (ops : SetOps<'S>) =
         let struct (set1, set2) = createByRemainder first second
 
         Assert.AreEqual<bool>(
-            Set.isProperSuperset (remainders first) (remainders second),
+            Set.isProperSuperset (SetInputs.Remainders first) (SetInputs.Remainders second),
             ops.IsProperSuperset set1 set2,
             $"%s{ops.Name}.isProperSuperset must count the elements that the comparer of the first set finds equal once"
         )
@@ -283,7 +280,7 @@ type SetContract<'S> (ops : SetOps<'S>) =
         let struct (set1, set2) = createByRemainder first second
 
         Assert.AreEqual<bool>(
-            Set.isSubset (remainders first) (remainders second),
+            Set.isSubset (SetInputs.Remainders first) (SetInputs.Remainders second),
             ops.IsSubset set1 set2,
             $"%s{ops.Name}.isSubset must count the elements that the comparer of the first set finds equal once"
         )
@@ -293,7 +290,7 @@ type SetContract<'S> (ops : SetOps<'S>) =
         let struct (set1, set2) = createByRemainder first second
 
         Assert.AreEqual<bool>(
-            Set.isSuperset (remainders first) (remainders second),
+            Set.isSuperset (SetInputs.Remainders first) (SetInputs.Remainders second),
             ops.IsSuperset set1 set2,
             $"%s{ops.Name}.isSuperset must count the elements that the comparer of the first set finds equal once"
         )
@@ -303,7 +300,7 @@ type SetContract<'S> (ops : SetOps<'S>) =
         let struct (set1, set2) = createByRemainder first second
 
         Assert.AreEqual<bool>(
-            not (Set.isEmpty (Set.intersect (remainders first) (remainders second))),
+            not (Set.isEmpty (Set.intersect (SetInputs.Remainders first) (SetInputs.Remainders second))),
             ops.Overlaps set1 set2,
             $"%s{ops.Name}.overlaps must compare in the comparer of the first set"
         )
@@ -313,7 +310,7 @@ type SetContract<'S> (ops : SetOps<'S>) =
         let struct (set1, set2) = createByRemainder first second
 
         Assert.AreEqual<bool>(
-            (remainders first = remainders second),
+            (SetInputs.Remainders first = SetInputs.Remainders second),
             ops.SetEquals set1 set2,
             $"%s{ops.Name}.setEquals must count the elements that the comparer of the first set finds equal once"
         )

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

@@ -38,6 +38,17 @@ type SetCreationContract<'S when 'S :> seq<int>> (ops : SetCreationOps<'S>) =
         for element in elements do
             Assert.Contains (element, input, $"%s{message} must hold elements of the input")
 
+    /// Creates a set from a copy of an input and changes the copy afterwards, so that a set that shared the memory of its
+    /// source would show the change.
+    let createFromChangedCopy (create : int array -> 'S) (input : int array) =
+        let source = Array.copy input
+        let set = create source
+
+        if source.Length > 0 then
+            source[0] <- 1000
+
+        set
+
     // ---- Creation ----
 
     [<TestMethod>]
@@ -46,16 +57,9 @@ type SetCreationContract<'S when 'S :> seq<int>> (ops : SetCreationOps<'S>) =
 
     [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
     member this.``ofArray copies the distinct elements`` (input : int array) =
-        // The test changes the array after the call, so it changes a copy of its row
-        let source = Array.copy input
-        let set = ops.OfArray source
-
-        if source.Length > 0 then
-            source[0] <- 1000
-
         CollectionAssert.AreEqual (
             Set.toArray (Set.ofArray input),
-            this.Sorted set,
+            this.Sorted (createFromChangedCopy ops.OfArray input),
             $"%s{ops.Name}.ofArray must copy the distinct elements"
         )
 
@@ -82,6 +86,14 @@ type SetCreationContract<'S when 'S :> seq<int>> (ops : SetCreationOps<'S>) =
             "ofList of a null list must throw"
         )
 
+    [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
+    member this.``ofReadOnlySpan copies the distinct elements`` (input : int array) =
+        CollectionAssert.AreEqual (
+            Set.toArray (Set.ofArray input),
+            this.Sorted (createFromChangedCopy ops.OfReadOnlySpan input),
+            $"%s{ops.Name}.ofReadOnlySpan must copy the distinct elements"
+        )
+
     [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
     member this.``ofSeq keeps the distinct elements`` (input : int array) =
         let expected = Set.toArray (Set.ofArray input)
@@ -113,6 +125,14 @@ type SetCreationContract<'S when 'S :> seq<int>> (ops : SetCreationOps<'S>) =
             "ofSeq of a null sequence must throw"
         )
 
+    [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
+    member this.``ofSpan copies the distinct elements`` (input : int array) =
+        CollectionAssert.AreEqual (
+            Set.toArray (Set.ofArray input),
+            this.Sorted (createFromChangedCopy ops.OfSpan input),
+            $"%s{ops.Name}.ofSpan must copy the distinct elements"
+        )
+
     [<TestMethod>]
     member this.``singleton has one element`` () =
         CollectionAssert.AreEqual ([| 42 |], this.Sorted (ops.Singleton 42), $"%s{ops.Name}.singleton must have one element")
@@ -127,14 +147,7 @@ type SetCreationContract<'S when 'S :> seq<int>> (ops : SetCreationOps<'S>) =
 
     [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
     member _.``the struct copies one element of the array for each class of its comparer`` (input : int array) =
-        // The test changes the array after the call, so it changes a copy of its row
-        let source = Array.copy input
-        let set = custom.OfArray source
-
-        if source.Length > 0 then
-            source[0] <- 1000
-
-        holdsOnePerRemainder input set $"%s{customName}.ofArray"
+        holdsOnePerRemainder input (createFromChangedCopy custom.OfArray input) $"%s{customName}.ofArray"
 
     [<TestMethod>]
     member this.``the struct throws for a null array as FSharp.Core does`` () =
@@ -158,6 +171,10 @@ type SetCreationContract<'S when 'S :> seq<int>> (ops : SetCreationOps<'S>) =
             "forComparer ofList of a null list must throw"
         )
 
+    [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
+    member _.``the struct copies one element of the read-only span for each class of its comparer`` (input : int array) =
+        holdsOnePerRemainder input (createFromChangedCopy custom.OfReadOnlySpan input) $"%s{customName}.ofReadOnlySpan"
+
     [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
     member _.``the struct keeps one element of the sequence for each class of its comparer`` (input : int array) =
         holdsOnePerRemainder input (custom.OfSeq (List.ofArray input)) $"%s{customName}.ofSeq of a list"
@@ -184,6 +201,10 @@ type SetCreationContract<'S when 'S :> seq<int>> (ops : SetCreationOps<'S>) =
             "forComparer ofSeq of a null sequence must throw"
         )
 
+    [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
+    member _.``the struct copies one element of the span for each class of its comparer`` (input : int array) =
+        holdsOnePerRemainder input (createFromChangedCopy custom.OfSpan input) $"%s{customName}.ofSpan"
+
     [<TestMethod>]
     member _.``the struct creates a set of one element with its comparer`` () =
         holdsOnePerRemainder [| 42 |] (custom.Singleton 42) $"%s{customName}.singleton"

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

@@ -49,6 +49,37 @@ type SetInputs =
                 struct (first, second)
     }
 
+    /// <summary>
+    /// The pairs of inputs whose second input is a subset of the first one, as rows: the second input adds nothing to the
+    /// first one, and empty and equal inputs are among them.
+    /// </summary>
+    static member SubsetPairs =
+        SetInputs.Pairs
+        |> Seq.filter (fun struct (first, second) -> Set.isSubset (Set.ofArray second) (Set.ofArray first))
+
+    /// <summary>
+    /// The pairs of inputs whose remainders in the division by 5 are all remainders of the first input too, as rows: the
+    /// second input adds nothing to a set that compares by remainders, although it may hold other numbers.
+    /// </summary>
+    static member SubsetPairsByRemainder =
+        SetInputs.Pairs
+        |> Seq.filter (fun struct (first, second) -> Set.isSubset (SetInputs.Remainders second) (SetInputs.Remainders first))
+
+    /// The pairs of inputs that have no number in common, as rows: the second input removes nothing from the first one.
+    static member DisjointPairs =
+        SetInputs.Pairs
+        |> Seq.filter (fun struct (first, second) -> Set.isEmpty (Set.intersect (Set.ofArray first) (Set.ofArray second)))
+
+    /// <summary>
+    /// The pairs of inputs that have no remainder in the division by 5 in common, as rows: the second input removes nothing
+    /// from a set that compares by remainders, although it may hold numbers of the first input.
+    /// </summary>
+    static member DisjointPairsByRemainder =
+        SetInputs.Pairs
+        |> Seq.filter (fun struct (first, second) ->
+            Set.isEmpty (Set.intersect (SetInputs.Remainders first) (SetInputs.Remainders second))
+        )
+
     /// The values to look up: in no input, in one input and in several inputs.
     static member Values = [| 42; 5; -3; 8; 1000 |]
 
@@ -69,6 +100,10 @@ type SetInputs =
     /// </remarks>
     static member Remainder (item : int) = ((item % 5) + 5) % 5
 
+    /// The remainders of the numbers of an input in the division by 5, as a set: the classes of the numbers for a set that
+    /// compares by remainders.
+    static member Remainders (input : int array) = Set.ofArray (Array.map SetInputs.Remainder input)
+
     /// The equality comparer of the structs that create hash and frozen sets: equal remainders make equal numbers.
     static member SameRemainder = sameRemainder
 

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

@@ -11,6 +11,14 @@ open Microsoft.VisualStudio.TestTools.UnitTesting
 type SetMutationContract<'S> (ops : SetMutationOps<'S>) =
     inherit SetContractBase<'S> (ops.Name, ops.ParamName, ops.OfSeq, ops.ToArray)
 
+    /// An input in the shapes that a sequence argument takes, each with its name for the message of the assertion: an
+    /// array, a list and a lazy sequence.
+    static let shapes (input : int array) = [|
+        struct ("an array", input :> seq<int>)
+        struct ("a list", List.ofArray input :> seq<int>)
+        struct ("a lazy sequence", Seq.map id input)
+    |]
+
     [<TestMethod; DynamicData(nameof SetInputs.InputsAndValues, typeof<SetInputs>)>]
     member this.``add adds a value that the set does not contain`` (input : int array, value : int) =
         let struct (set, expected) = this.Create input
@@ -32,6 +40,78 @@ type SetMutationContract<'S> (ops : SetMutationOps<'S>) =
             $"%s{ops.Name}.add must not change its input"
         )
 
+    [<TestMethod; DynamicData(nameof SetInputs.Pairs, typeof<SetInputs>)>]
+    member this.``addRange adds the elements that the set does not contain`` (first : int array, second : int array) =
+        let struct (set, expected) = this.Create first
+        let expected = Set.toArray (Set.union expected (Set.ofArray second))
+
+        for struct (shape, elements) in shapes second do
+            CollectionAssert.AreEqual (
+                expected,
+                this.Sorted (ops.AddRange elements set),
+                $"%s{ops.Name}.addRange of %s{shape} must add the elements that the set does not contain"
+            )
+
+    // The elements of the set stay, and of the elements that are new to it the first one of each class is added (D14)
+    [<TestMethod; DynamicData(nameof SetInputs.Pairs, typeof<SetInputs>)>]
+    member this.``addRange keeps the elements of the set that the comparer finds equal`` (first : int array, second : int array) =
+        let set = ops.OfSeqByRemainder first
+        let held = ops.ToArray set
+        let classes = SetInputs.Remainders held
+
+        let added =
+            second
+            |> Array.filter (fun item -> not (Set.contains (SetInputs.Remainder item) classes))
+            |> Array.distinctBy SetInputs.Remainder
+
+        for struct (shape, elements) in shapes second do
+            CollectionAssert.AreEqual (
+                Array.sort (Array.append held added),
+                this.Sorted (ops.AddRange elements set),
+                $"%s{ops.Name}.addRange of %s{shape} must keep the elements of the set and add the first of the other elements of each remainder"
+            )
+
+    [<TestMethod>]
+    member this.``addRange leaves the input unchanged`` () =
+        let set = ops.OfSeq Inputs.Several
+        ops.AddRange Inputs.Other set |> ignore
+
+        CollectionAssert.AreEqual (
+            Set.toArray (Set.ofArray Inputs.Several),
+            this.Sorted set,
+            $"%s{ops.Name}.addRange must not change its input"
+        )
+
+    [<TestMethod; DynamicData(nameof SetInputs.SubsetPairs, typeof<SetInputs>)>]
+    member _.``addRange returns the input when the sequence adds no element`` (first : int array, second : int array) =
+        let set = ops.OfSeq first
+
+        Assert.AreSame (
+            box set,
+            box (ops.AddRange second set),
+            $"%s{ops.Name}.addRange must return the input when the sequence adds no element"
+        )
+
+    [<TestMethod; DynamicData(nameof SetInputs.SubsetPairsByRemainder, typeof<SetInputs>)>]
+    member _.``addRange returns the input when the comparer finds every element of the sequence in the set``
+        (first : int array, second : int array)
+        =
+        let set = ops.OfSeqByRemainder first
+
+        Assert.AreSame (
+            box set,
+            box (ops.AddRange second set),
+            $"%s{ops.Name}.addRange must return the input when the comparer finds every element of the sequence in the set"
+        )
+
+    [<TestMethod>]
+    member this.``addRange throws ArgumentNullException for a null sequence`` () =
+        this.ThrowsArgumentNull (
+            "elements",
+            (fun () -> ops.AddRange (Unchecked.defaultof<seq<int>>) (ops.OfSeq Inputs.Several)),
+            "addRange of a null sequence must throw"
+        )
+
     [<TestMethod; DynamicData(nameof SetInputs.All, typeof<SetInputs>)>]
     member this.``clear removes every element`` (input : int array) =
         let struct (set, _) = this.Create input
@@ -57,3 +137,76 @@ type SetMutationContract<'S> (ops : SetMutationOps<'S>) =
             this.Sorted set,
             $"%s{ops.Name}.remove must not change its input"
         )
+
+    [<TestMethod; DynamicData(nameof SetInputs.Pairs, typeof<SetInputs>)>]
+    member this.``removeRange removes the elements that the sequence contains`` (first : int array, second : int array) =
+        let struct (set, expected) = this.Create first
+        let expected = Set.toArray (Set.difference expected (Set.ofArray second))
+
+        for struct (shape, elements) in shapes second do
+            CollectionAssert.AreEqual (
+                expected,
+                this.Sorted (ops.RemoveRange elements set),
+                $"%s{ops.Name}.removeRange of %s{shape} must remove the elements that the sequence contains"
+            )
+
+    // The comparer of the set decides which elements are equal to those of the sequence (D14)
+    [<TestMethod; DynamicData(nameof SetInputs.Pairs, typeof<SetInputs>)>]
+    member this.``removeRange removes the elements that the comparer finds equal`` (first : int array, second : int array) =
+        let set = ops.OfSeqByRemainder first
+        let classes = SetInputs.Remainders second
+
+        let remaining =
+            ops.ToArray set
+            |> Array.filter (fun item -> not (Set.contains (SetInputs.Remainder item) classes))
+            |> Array.sort
+
+        for struct (shape, elements) in shapes second do
+            CollectionAssert.AreEqual (
+                remaining,
+                this.Sorted (ops.RemoveRange elements set),
+                $"%s{ops.Name}.removeRange of %s{shape} must remove the elements that the comparer finds equal to those of the sequence"
+            )
+
+    [<TestMethod>]
+    member this.``removeRange leaves the input unchanged`` () =
+        let set = ops.OfSeq Inputs.Several
+        ops.RemoveRange Inputs.Other set |> ignore
+
+        CollectionAssert.AreEqual (
+            Set.toArray (Set.ofArray Inputs.Several),
+            this.Sorted set,
+            $"%s{ops.Name}.removeRange must not change its input"
+        )
+
+    [<TestMethod; DynamicData(nameof SetInputs.DisjointPairs, typeof<SetInputs>)>]
+    member _.``removeRange returns the input when the sequence has no element of the set``
+        (first : int array, second : int array)
+        =
+        let set = ops.OfSeq first
+
+        Assert.AreSame (
+            box set,
+            box (ops.RemoveRange second set),
+            $"%s{ops.Name}.removeRange must return the input when the sequence has no element of the set"
+        )
+
+    [<TestMethod; DynamicData(nameof SetInputs.DisjointPairsByRemainder, typeof<SetInputs>)>]
+    member _.``removeRange returns the input when the comparer finds no element of the sequence in the set``
+        (first : int array, second : int array)
+        =
+        let set = ops.OfSeqByRemainder first
+
+        Assert.AreSame (
+            box set,
+            box (ops.RemoveRange second set),
+            $"%s{ops.Name}.removeRange must return the input when the comparer finds no element of the sequence in the set"
+        )
+
+    [<TestMethod>]
+    member this.``removeRange throws ArgumentNullException for a null sequence`` () =
+        this.ThrowsArgumentNull (
+            "elements",
+            (fun () -> ops.RemoveRange (Unchecked.defaultof<seq<int>>) (ops.OfSeq Inputs.Several)),
+            "removeRange of a null sequence must throw"
+        )