Add equivalent assertion and related tests

Author: RJSonnenberg

src/FsUnit.Xunit/FsUnit.fs

@@ -57,6 +57,9 @@ let equalSeq expected =
 let equal expected =
     CustomMatchers.equal expected
 
+let equivalent expected =
+    CustomMatchers.equivalent (fun e a -> Assert.Equivalent(e, a, true)) expected
+
 let equalWithin (tolerance: obj) (expected: obj) =
     CustomMatchers.equalWithin tolerance expected
 

src/FsUnit.Xunit/FsUnitTyped.fs

@@ -11,6 +11,10 @@ module TopLevelOperators =
     let shouldEqual<'a> (expected: 'a) (actual: 'a) =
         actual |> should equal expected
 
+    [<DebuggerStepThrough>]
+    let shouldEquivalent<'a when 'a: equality> (expected: 'a seq) (actual: 'a seq) =
+        actual |> should equivalent expected
+
     [<DebuggerStepThrough>]
     let shouldNotEqual<'a> (expected: 'a) (actual: 'a) =
         actual |> should not' (equal expected)

tests/FsUnit.Xunit.Test/FsUnit.Xunit.Test.fsproj

@@ -45,6 +45,7 @@
     <Compile Include="typed.shouldContainTextTests.fs" />
     <Compile Include="typed.shouldFailTests.fs" />
     <Compile Include="typed.shouldEqualTests.fs" />
+    <Compile Include="equivalentTests.fs" />
     <None Include="paket.references" />
   </ItemGroup>
   <ItemGroup>

tests/FsUnit.Xunit.Test/equivalentTests.fs

@@ -0,0 +1,40 @@
+namespace FsUnit.Test
+
+open System
+open Xunit
+open FsUnit.Xunit
+
+module EquivalentTests =
+
+    [<Fact>]
+    let ``two lists with same elements in different order are equivalent`` () =
+        [1;2;3] |> should equivalent [3;2;1]
+
+    [<Fact>]
+    let ``two lists with different elements are not equivalent`` () =
+        [1;2;3] |> should not' (equivalent [4;5;6])
+
+    [<Fact>]
+    let ``two lists with different lengths are not equivalent`` () =
+        [1;2;3] |> should not' (equivalent [1;2])
+
+    [<Fact>]
+    let ``two arrays with same elements in different order are equivalent`` () =
+        [|1;2;3|] |> should equivalent [|3;2;1|]
+
+    [<Fact>]
+    let ``two arrays with different elements are not equivalent`` () =
+        [|1;2;3|] |> should not' (equivalent [|4;5;6|])
+
+    [<Fact>]
+    let ``empty collections are equivalent`` () =
+        [] |> should equivalent []
+        [||] |> should equivalent [||]
+
+    [<Fact>]
+    let ``collections with same elements and duplicates are not equivalent if counts differ`` () =
+        [1;1;2] |> should not' (equivalent [1;2;2])
+
+    [<Fact>]
+    let ``collections with same elements and same counts are equivalent`` () =
+        [1;1;2] |> should equivalent [2;1;1]