fixup! test: FrozenSet against the set contracts

Tests of the gaps of the sets report (package B4):

- `FrozenSetOps` fills the new `OfReadOnlySpan` and `OfSpan` fields of `SetCreationOps` and
  `SetCustomComparerOps`, so the shared creation contract runs `ofReadOnlySpan` and
  `ofSpan` of the module and of the struct on a copy of each input that it changes after
  the call.
- `FrozenSetTests` lists the new functions in the tables of the creation functions and of
  the members of the struct, which check the comparer and the element that stays of
  "apple" and "APPLE". The shared contract states only that one element of each class
  stays, so two tests pin which one: the span members of the struct keep the first
  element in both orders, and the span functions of the module keep the first of two equal
  string instances, in both orders.
- A third test pins the rule that the remarks of `CustomComparerFrozenSet.ofSeq` state: it
  returns a frozen set whose comparer equals its comparer, not only the same instance
  (ADR 0001, D14).

Each new behavior was broken once in the code, 10 mutations (the comparer and the element
that stays of the four span creators, a dropped element, and the instance test of `ofSeq`),
and a test failed each time.

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

Author: xperiandri

tests/FSharp.Collections.Immutable.Tests/FrozenSet/FrozenSetOps.fs

@@ -2,6 +2,7 @@
 [<RequireQualifiedAccess>]
 module FSharp.Collections.Immutable.Tests.FrozenSetOps
 
+open System
 open System.Collections.Frozen
 open System.Collections.Generic
 open FSharp.Collections.Immutable
@@ -75,7 +76,9 @@ let creation : SetCreationOps<FrozenSet<int>> =
         Empty = fun () -> FrozenSet.empty
         OfArray = FrozenSet.ofArray
         OfList = FrozenSet.ofList
+        OfReadOnlySpan = fun array -> FrozenSet.ofReadOnlySpan (ReadOnlySpan<int> array)
         OfSeq = FrozenSet.ofSeq
+        OfSpan = fun array -> FrozenSet.ofSpan (Span<int> array)
         Singleton = FrozenSet.singleton
 
         CustomComparer = {
@@ -84,7 +87,9 @@ let creation : SetCreationOps<FrozenSet<int>> =
             Empty = fun () -> custom.empty
             OfArray = fun array -> custom.ofArray array
             OfList = fun elements -> custom.ofList elements
+            OfReadOnlySpan = fun array -> custom.ofReadOnlySpan (ReadOnlySpan<int> array)
             OfSeq = fun elements -> custom.ofSeq elements
+            OfSpan = fun array -> custom.ofSpan (Span<int> array)
             Singleton = fun value -> custom.singleton value
         }
     }

tests/FSharp.Collections.Immutable.Tests/FrozenSet/FrozenSetTests.fs

@@ -3,6 +3,7 @@ namespace FSharp.Collections.Immutable.Tests
 open System
 open System.Collections.Frozen
 open System.Collections.Generic
+open System.Globalization
 open System.Runtime.InteropServices
 open FSharp.Collections.Immutable
 open Microsoft.VisualStudio.TestTools.UnitTesting
@@ -154,7 +155,9 @@ type FrozenSetTests () =
             nameof FrozenSet.ofArray, (fun () -> FrozenSet.ofArray [| "a" |])
             // The function under test takes a list
             nameof FrozenSet.ofList, (fun () -> FrozenSet.ofList [ "a" ])
+            nameof FrozenSet.ofReadOnlySpan, (fun () -> FrozenSet.ofReadOnlySpan (ReadOnlySpan<string> [| "a" |]))
             nameof FrozenSet.ofSeq, (fun () -> FrozenSet.ofSeq (Seq.singleton "a"))
+            nameof FrozenSet.ofSpan, (fun () -> FrozenSet.ofSpan (Span<string> [| "a" |]))
             nameof FrozenSet.singleton, (fun () -> FrozenSet.singleton "a")
         |]
 
@@ -165,7 +168,9 @@ type FrozenSetTests () =
             nameof caseless.ofArray, (fun () -> caseless.ofArray [| "apple"; "APPLE" |])
             // The member under test takes a list
             nameof caseless.ofList, (fun () -> caseless.ofList [ "apple"; "APPLE" ])
+            nameof caseless.ofReadOnlySpan, (fun () -> caseless.ofReadOnlySpan (ReadOnlySpan<string> [| "apple"; "APPLE" |]))
             nameof caseless.ofSeq, (fun () -> caseless.ofSeq (Seq.ofArray [| "apple"; "APPLE" |]))
+            nameof caseless.ofSpan, (fun () -> caseless.ofSpan (Span<string> [| "apple"; "APPLE" |]))
             nameof caseless.singleton, (fun () -> caseless.singleton "apple" |> add "APPLE")
         |]
 
@@ -382,6 +387,54 @@ type FrozenSetTests () =
             $"CustomComparerFrozenSet.%s{name} must keep the first of the elements that the comparer considers equal"
         )
 
+    // The shared contract states that one element of each class stays. Which one stays is a property of the BCL member that
+    // creates the set, so each module pins it, here in both orders of the input.
+    [<TestMethod;
+      DataRow("ofReadOnlySpan", "apple", "APPLE");
+      DataRow("ofReadOnlySpan", "APPLE", "apple");
+      DataRow("ofSpan", "apple", "APPLE");
+      DataRow("ofSpan", "APPLE", "apple")>]
+    member _.``the span members of the struct keep the first of the elements that its comparer considers equal``
+        (name : string, first : string, second : string)
+        =
+        let input = [| first; second |]
+
+        let set =
+            match name with
+            | "ofReadOnlySpan" -> caseless.ofReadOnlySpan (ReadOnlySpan<string> input)
+            | "ofSpan" -> caseless.ofSpan (Span<string> input)
+            | name -> failwith $"CustomComparerFrozenSet has no span member %s{name}"
+
+        Assert.AreEqual<string>(
+            first,
+            Assert.ContainsSingle (set, $"CustomComparerFrozenSet.%s{name} must compare without case"),
+            $"CustomComparerFrozenSet.%s{name} must keep the first of the elements that the comparer considers equal"
+        )
+
+    [<TestMethod; DataRow "ofReadOnlySpan"; DataRow "ofSpan">]
+    member _.``the span functions keep the first of the elements that are equal in the default comparer`` (name : string) =
+        // Two strings that are equal and are two instances, so the instance tells which one stays
+        let first = String ('x', 3)
+        let second = String ('x', 3)
+
+        let create (input : string array) =
+            match name with
+            | "ofReadOnlySpan" -> FrozenSet.ofReadOnlySpan (ReadOnlySpan<string> input)
+            | "ofSpan" -> FrozenSet.ofSpan (Span<string> input)
+            | name -> failwith $"FrozenSet has no span function %s{name}"
+
+        Assert.AreSame (
+            first,
+            Assert.ContainsSingle (create [| first; second |], $"FrozenSet.%s{name} must hold equal elements once"),
+            $"FrozenSet.%s{name} must keep the first of the elements that are equal"
+        )
+
+        Assert.AreSame (
+            second,
+            Assert.ContainsSingle (create [| second; first |], $"FrozenSet.%s{name} must hold equal elements once"),
+            $"FrozenSet.%s{name} must keep the first of the elements that are equal in either order"
+        )
+
     [<TestMethod>]
     member _.``the struct gives an existing frozen set its comparer`` () =
         let set = FrozenSet.ofArray [| "apple"; "APPLE"; "Banana" |]
@@ -564,6 +617,22 @@ type FrozenSetTests () =
             "CustomComparerFrozenSet.ofSeq of a frozen set with the comparer must not copy it"
         )
 
+    // ToFrozenSet returns a frozen set whose comparer Equals the comparer, not only the same instance (ADR 0001, D14)
+    [<TestMethod>]
+    member _.``the struct returns a frozen set whose comparer equals its comparer`` () =
+        let first : IEqualityComparer<string> = StringComparer.Create (CultureInfo.InvariantCulture, true)
+        let second : IEqualityComparer<string> = StringComparer.Create (CultureInfo.InvariantCulture, true)
+        Assert.AreNotSame (first, second, "The test needs two comparer instances")
+        Assert.AreEqual<obj>(first, second, "The test needs two comparers that are equal")
+
+        let set = (FrozenSet.forComparer first).ofArray [| "apple"; "Banana" |]
+
+        Assert.AreSame (
+            set,
+            (FrozenSet.forComparer second).ofSeq set,
+            "CustomComparerFrozenSet.ofSeq must return a frozen set whose comparer equals its comparer"
+        )
+
     [<TestMethod>]
     member _.``intersectMany of one frozen set returns it`` () =
         let set = words ()