diff --git a/tests/FSharp.MongoDB.Bson.Tests/FSharp.MongoDB.Bson.Tests.fsproj b/tests/FSharp.MongoDB.Bson.Tests/FSharp.MongoDB.Bson.Tests.fsproj
index 57c1928..3ff5ca6 100644
--- a/tests/FSharp.MongoDB.Bson.Tests/FSharp.MongoDB.Bson.Tests.fsproj
+++ b/tests/FSharp.MongoDB.Bson.Tests/FSharp.MongoDB.Bson.Tests.fsproj
@@ -29,7 +29,6 @@
     <PackageReference Include="NUnit" Version="4.2.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-    <PackageReference Include="Unquote" Version="7.0.1" />
   </ItemGroup>
 
 </Project>
\ No newline at end of file
diff --git a/tests/FSharp.MongoDB.Bson.Tests/FSharpListSerializationTests.fs b/tests/FSharp.MongoDB.Bson.Tests/FSharpListSerializationTests.fs
index 1a12b11..67439e4 100644
--- a/tests/FSharp.MongoDB.Bson.Tests/FSharpListSerializationTests.fs
+++ b/tests/FSharp.MongoDB.Bson.Tests/FSharpListSerializationTests.fs
@@ -15,10 +15,10 @@
 
 namespace FSharp.MongoDB.Bson.Tests.Serialization
 
+open FsUnit
 open MongoDB.Bson
 
 open NUnit.Framework
-open Swensen.Unquote
 
 module FSharpListSerialization =
 
@@ -28,55 +28,55 @@ module FSharpListSerialization =
     let ``test serialize an empty list``() =
         let value = { Ints = [] }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument("Ints", BsonArray List.empty<int>)
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize an empty list``() =
         let doc = BsonDocument("Ints", BsonArray List.empty<int>)
 
-        let result = <@ deserialize doc typeof<Record> @>
+        let result = deserialize doc typeof<Record>
         let expected = { Ints = [] }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test serialize a list of one element``() =
         let value = { Ints = [ 0 ] }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument("Ints", BsonArray [ 0 ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize a list of one element``() =
         let doc = BsonDocument("Ints", BsonArray [ 0 ])
 
-        let result = <@ deserialize doc typeof<Record> @>
+        let result = deserialize doc typeof<Record>
         let expected = { Ints = [ 0 ] }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test serialize a list of multiple elements``() =
         let value = { Ints = [ 1; 2; 3 ] }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument("Ints", BsonArray [ 1; 2; 3 ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize a list of multiple elements``() =
         let doc = BsonDocument("Ints", BsonArray [ 1; 2; 3 ])
 
-        let result = <@ deserialize doc typeof<Record> @>
+        let result = deserialize doc typeof<Record>
         let expected = { Ints = [ 1; 2; 3 ] }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     module OptionType =
 
@@ -86,19 +86,19 @@ module FSharpListSerialization =
         let ``test serialize a list of optional strings``() =
             let value = { MaybeStrings = [ Some "a"; None; Some "z" ] }
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument("MaybeStrings", BsonArray [ "a"; null; "z" ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a list of optional strings``() =
             let doc = BsonDocument("MaybeStrings", BsonArray [ "a"; null; "z" ])
 
-            let result = <@ deserialize doc typeof<Record> @>
+            let result = deserialize doc typeof<Record>
             let expected = { MaybeStrings = [ Some "a"; None; Some "z" ] }
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
     module RecordType =
 
@@ -114,7 +114,7 @@ module FSharpListSerialization =
                                        { Key = "b"; Value = 2 }
                                        { Key = "c"; Value = 3 } ] }
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected =
                 BsonDocument(
                     "Elements",
@@ -125,7 +125,7 @@ module FSharpListSerialization =
                                 BsonDocument [ BsonElement("Key", BsonString "c")
                                                BsonElement("Value", BsonInt32 3) ] ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a list of record types``() =
@@ -139,9 +139,9 @@ module FSharpListSerialization =
                                 BsonDocument [ BsonElement("Key", BsonString "c")
                                                BsonElement("Value", BsonInt32 3) ] ])
 
-            let result = <@ deserialize doc typeof<Record> @>
+            let result = deserialize doc typeof<Record>
             let expected = { Elements = [ { Key = "a"; Value = 1 }
                                           { Key = "b"; Value = 2 }
                                           { Key = "c"; Value = 3 } ] }
 
-            test <@ %result = expected @>
+            result |> should equal expected
diff --git a/tests/FSharp.MongoDB.Bson.Tests/FSharpMapSerializationTests.fs b/tests/FSharp.MongoDB.Bson.Tests/FSharpMapSerializationTests.fs
index d6d21c1..c2d3e3f 100644
--- a/tests/FSharp.MongoDB.Bson.Tests/FSharpMapSerializationTests.fs
+++ b/tests/FSharp.MongoDB.Bson.Tests/FSharpMapSerializationTests.fs
@@ -15,10 +15,10 @@
 
 namespace FSharp.MongoDB.Bson.Tests.Serialization
 
+open FsUnit
 open MongoDB.Bson
 
 open NUnit.Framework
-open Swensen.Unquote
 
 module FSharpMapSerialization =
 
@@ -35,13 +35,13 @@ module FSharpMapSerialization =
                       String = Map.empty<string, string>
                       Float = Map.empty<string, float> }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument([ BsonElement("Bool", BsonDocument())
                                       BsonElement("Int", BsonDocument())
                                       BsonElement("String", BsonDocument())
                                       BsonElement("Float", BsonDocument()) ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize an empty map``() =
@@ -50,13 +50,13 @@ module FSharpMapSerialization =
                                  BsonElement("String", BsonDocument())
                                  BsonElement("Float", BsonDocument()) ])
 
-        let result = <@ deserialize doc typeof<Primitive> @>
+        let result = deserialize doc typeof<Primitive>
         let expected = { Bool = Map.empty<string, bool>
                          Int = Map.empty<string, int>
                          String = Map.empty<string, string>
                          Float = Map.empty<string, float> }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test serialize a map of one element``() =
@@ -65,13 +65,13 @@ module FSharpMapSerialization =
                       String = Map.ofList<string, string> [ ("a", "0.0") ]
                       Float = Map.ofList<string, float> [ ("a", 0.0) ] }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument([ BsonElement("Bool", BsonDocument("a", BsonBoolean false))
                                       BsonElement("Int", BsonDocument("a", BsonInt32 0))
                                       BsonElement("String", BsonDocument("a", BsonString "0.0"))
                                       BsonElement("Float", BsonDocument("a", BsonDouble 0.0)) ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize a map of one element``() =
@@ -80,13 +80,13 @@ module FSharpMapSerialization =
                                  BsonElement("String", BsonDocument("a", BsonString "0.0"))
                                  BsonElement("Float", BsonDocument("a", BsonDouble 0.0)) ])
 
-        let result = <@ deserialize doc typeof<Primitive> @>
+        let result = deserialize doc typeof<Primitive>
         let expected = { Bool = Map.ofList<string, bool> [ ("a", false) ]
                          Int = Map.ofList<string, int> [ ("a", 0) ]
                          String = Map.ofList<string, string> [ ("a", "0.0") ]
                          Float = Map.ofList<string, float> [ ("a", 0.0) ] }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test serialize a map of multiple elements``() =
@@ -96,7 +96,7 @@ module FSharpMapSerialization =
               String = Map.ofList<string, string> [ ("a", "0.0"); ("b", "1.0"); ("c", "2.0") ]
               Float = Map.ofList<string, float> [ ("a", 0.0); ("b", 1.0); ("c", 2.0) ] }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected =
             BsonDocument(
                 [ BsonElement("Bool", BsonDocument([ BsonElement("a", BsonBoolean false)
@@ -112,7 +112,7 @@ module FSharpMapSerialization =
                                                       BsonElement("b", BsonDouble 1.0)
                                                       BsonElement("c", BsonDouble 2.0) ])) ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize a map of multiple elements``() =
@@ -131,11 +131,11 @@ module FSharpMapSerialization =
                                                       BsonElement("b", BsonDouble 1.0)
                                                       BsonElement("c", BsonDouble 2.0) ])) ])
 
-        let result = <@ deserialize doc typeof<Primitive> @>
+        let result = deserialize doc typeof<Primitive>
         let expected =
             { Bool = Map.ofList<string, bool> [ ("a", false); ("b", true); ("c", false) ]
               Int = Map.ofList<string, int> [ ("a", 0); ("b", 1); ("c", 2) ]
               String = Map.ofList<string, string> [ ("a", "0.0"); ("b", "1.0"); ("c", "2.0") ]
               Float = Map.ofList<string, float> [ ("a", 0.0); ("b", 1.0); ("c", 2.0) ] }
 
-        test <@ %result = expected @>
+        result |> should equal expected
diff --git a/tests/FSharp.MongoDB.Bson.Tests/FSharpOptionSerializationTests.fs b/tests/FSharp.MongoDB.Bson.Tests/FSharpOptionSerializationTests.fs
index f3a037c..e515093 100644
--- a/tests/FSharp.MongoDB.Bson.Tests/FSharpOptionSerializationTests.fs
+++ b/tests/FSharp.MongoDB.Bson.Tests/FSharpOptionSerializationTests.fs
@@ -15,10 +15,10 @@
 
 namespace FSharp.MongoDB.Bson.Tests.Serialization
 
+open FsUnit
 open MongoDB.Bson
 
 open NUnit.Framework
-open Swensen.Unquote
 
 module FSharpOptionSerialization =
 
@@ -35,22 +35,22 @@ module FSharpOptionSerialization =
                        String = None
                        Float = None }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument()
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize optional primitives (none) in a record type)``() =
         let doc = BsonDocument()
 
-        let result = <@ deserialize doc typeof<Primitive> @>
+        let result = deserialize doc typeof<Primitive>
         let expected = { Bool = None
                          Int = None
                          String = None
                          Float = None }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test serialize optional primitives (some) in a record type``() =
@@ -59,13 +59,13 @@ module FSharpOptionSerialization =
                        String = Some "0.0"
                        Float = Some 0.0 }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument([ BsonElement("Bool", BsonBoolean false)
                                       BsonElement("Int", BsonInt32 0)
                                       BsonElement("String", BsonString "0.0")
                                       BsonElement("Float", BsonDouble 0.0) ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize optional primitives (some) in a record type``() =
@@ -74,10 +74,10 @@ module FSharpOptionSerialization =
                                  BsonElement("String", BsonString "1.0")
                                  BsonElement("Float", BsonDouble 1.0) ])
 
-        let result = <@ deserialize doc typeof<Primitive> @>
+        let result = deserialize doc typeof<Primitive>
         let expected = { Bool = Some true
                          Int = Some 1
                          String = Some "1.0"
                          Float = Some 1.0 }
 
-        test <@ %result = expected @>
+        result |> should equal expected
diff --git a/tests/FSharp.MongoDB.Bson.Tests/FSharpRecordSerializationTests.fs b/tests/FSharp.MongoDB.Bson.Tests/FSharpRecordSerializationTests.fs
index c0fa274..34d6808 100644
--- a/tests/FSharp.MongoDB.Bson.Tests/FSharpRecordSerializationTests.fs
+++ b/tests/FSharp.MongoDB.Bson.Tests/FSharpRecordSerializationTests.fs
@@ -15,10 +15,10 @@
 
 namespace FSharp.MongoDB.Bson.Tests.Serialization
 
+open FsUnit
 open MongoDB.Bson
 
 open NUnit.Framework
-open Swensen.Unquote
 
 module FSharpRecordSerialization =
 
@@ -35,13 +35,13 @@ module FSharpRecordSerialization =
                       String = "0.0"
                       Float = 0.0 }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument([ BsonElement("Bool", BsonBoolean false)
                                       BsonElement("Int", BsonInt32 0)
                                       BsonElement("String", BsonString "0.0")
                                       BsonElement("Float", BsonDouble 0.0) ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize primitives in a record type``() =
@@ -50,13 +50,13 @@ module FSharpRecordSerialization =
                                  BsonElement("String", BsonString "1.0")
                                  BsonElement("Float", BsonDouble 1.0) ])
 
-        let result = <@ deserialize doc typeof<Primitive> @>
+        let result = deserialize doc typeof<Primitive>
         let expected = { Bool = true
                          Int = 1
                          String = "1.0"
                          Float = 1.0 }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     module BindingFlags =
 
@@ -66,16 +66,16 @@ module FSharpRecordSerialization =
         let ``test serialize an internal record type``() =
             let value = { Field = 0 }
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument("Field", BsonInt32 0)
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize an internal record type``() =
             let doc = BsonDocument("Field", BsonInt32 1)
 
-            let result = <@ deserialize doc typeof<InternalRecord> @>
+            let result = deserialize doc typeof<InternalRecord>
             let expected = { Field = 1 }
 
-            test <@ %result = expected @>
+            result |> should equal expected
diff --git a/tests/FSharp.MongoDB.Bson.Tests/FSharpSetSerializationTests.fs b/tests/FSharp.MongoDB.Bson.Tests/FSharpSetSerializationTests.fs
index 489fc94..5592d5f 100644
--- a/tests/FSharp.MongoDB.Bson.Tests/FSharpSetSerializationTests.fs
+++ b/tests/FSharp.MongoDB.Bson.Tests/FSharpSetSerializationTests.fs
@@ -15,10 +15,10 @@
 
 namespace FSharp.MongoDB.Bson.Tests.Serialization
 
+open FsUnit
 open MongoDB.Bson
 
 open NUnit.Framework
-open Swensen.Unquote
 
 module FSharpSetSerialization =
 
@@ -28,55 +28,55 @@ module FSharpSetSerialization =
     let ``test serialize an empty set``() =
         let value = { Ints = Set.empty<int> }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument("Ints", BsonArray Set.empty<int>)
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize an empty set``() =
         let doc = BsonDocument("Ints", BsonArray Set.empty<int>)
 
-        let result = <@ deserialize doc typeof<Record> @>
+        let result = deserialize doc typeof<Record>
         let expected = { Ints = Set.empty<int> }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test serialize a set of one element``() =
         let value = { Ints = Set.ofList [ 0 ] }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument("Ints", BsonArray [ 0 ])
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize a set of one element``() =
         let doc = BsonDocument("Ints", BsonArray [ 0 ])
 
-        let result = <@ deserialize doc typeof<Record> @>
+        let result = deserialize doc typeof<Record>
         let expected = { Ints = Set.ofList [ 0 ] }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test serialize a set of multiple elements``() =
         let value = { Ints = Set.ofList [ 1; 2; 3 ] }
 
-        let result = <@ serialize value @>
+        let result = serialize value
         let expected = BsonDocument("Ints", BsonArray (Set.ofList [ 1; 2; 3 ]))
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     [<Test>]
     let ``test deserialize a set of multiple elements``() =
         let doc = BsonDocument("Ints", BsonArray [ 1; 2; 3 ])
 
-        let result = <@ deserialize doc typeof<Record> @>
+        let result = deserialize doc typeof<Record>
         let expected = { Ints = Set.ofList [ 1; 2; 3 ] }
 
-        test <@ %result = expected @>
+        result |> should equal expected
 
     module OptionType =
 
@@ -86,19 +86,19 @@ module FSharpSetSerialization =
         let ``test serialize a set of optional strings``() =
             let value = { MaybeStrings = Set.ofList [ Some "a"; None; Some "z" ] }
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument("MaybeStrings", BsonArray (Set.ofList ["a"; null; "z"]))
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a set of optional strings``() =
             let doc = BsonDocument("MaybeStrings", BsonArray [ "a"; null; "z" ])
 
-            let result = <@ deserialize doc typeof<Record> @>
+            let result = deserialize doc typeof<Record>
             let expected = { MaybeStrings = Set.ofList [ Some "a"; None; Some "z" ] }
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
     module RecordType =
 
@@ -114,7 +114,7 @@ module FSharpSetSerialization =
                                                   { Key = "b"; Value = 2 }
                                                   { Key = "c"; Value = 3 } ] }
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected =
                 BsonDocument(
                     "Elements",
@@ -125,7 +125,7 @@ module FSharpSetSerialization =
                                 BsonDocument [ BsonElement("Key", BsonString "c")
                                                BsonElement("Value", BsonInt32 3) ] ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a set of record types``() =
@@ -139,9 +139,9 @@ module FSharpSetSerialization =
                                 BsonDocument [ BsonElement("Key", BsonString "c")
                                                BsonElement("Value", BsonInt32 3) ] ])
 
-            let result = <@ deserialize doc typeof<Record> @>
+            let result = deserialize doc typeof<Record>
             let expected = { Elements = Set.ofList [ { Key = "a"; Value = 1 }
                                                      { Key = "b"; Value = 2 }
                                                      { Key = "c"; Value = 3 } ] }
 
-            test <@ %result = expected @>
+            result |> should equal expected
diff --git a/tests/FSharp.MongoDB.Bson.Tests/FSharpUnionSerializationTests.fs b/tests/FSharp.MongoDB.Bson.Tests/FSharpUnionSerializationTests.fs
index 9075225..130b843 100644
--- a/tests/FSharp.MongoDB.Bson.Tests/FSharpUnionSerializationTests.fs
+++ b/tests/FSharp.MongoDB.Bson.Tests/FSharpUnionSerializationTests.fs
@@ -15,10 +15,10 @@
 
 namespace FSharp.MongoDB.Bson.Tests.Serialization
 
+open FsUnit
 open MongoDB.Bson
 
 open NUnit.Framework
-open Swensen.Unquote
 
 module FSharpUnionSerialization =
 
@@ -39,8 +39,8 @@ module FSharpUnionSerialization =
           (Float 0.0, BsonDocument([ BsonElement("_t", BsonString "Float")
                                      BsonElement("Item", BsonDouble 0.0) ])) ]
         |> List.iter (fun (value, expected) ->
-            let result = <@ serialize value @>
-            test <@ %result = expected @>)
+            let result = serialize value
+            result |> should equal expected)
 
     [<Test>]
     let ``test deserialize primitives in a union case``() =
@@ -53,8 +53,8 @@ module FSharpUnionSerialization =
           (Float 1.0, BsonDocument([ BsonElement("_t", BsonString "Float")
                                      BsonElement("Item", BsonDouble 1.0) ])) ]
         |> List.iter (fun (expected, doc) ->
-            let result = <@ deserialize doc typeof<Primitive> @>
-            test <@ %result = expected @>)
+            let result = deserialize doc typeof<Primitive>
+            result |> should equal expected)
 
     module Arity =
 
@@ -68,50 +68,50 @@ module FSharpUnionSerialization =
         let ``test serialize a union case with arity 0``() =
             let value = Zero
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "Zero") ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a union case with arity 0``() =
             let doc = BsonDocument([ BsonElement("_t", BsonString "Zero") ])
 
-            let result = <@ deserialize doc typeof<Number> @>
+            let result = deserialize doc typeof<Number>
             let expected = Zero
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test serialize a union case with arity 1``() =
             let value = One 1
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "One")
                                           BsonElement("Item", BsonInt32 1) ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a union case with arity 1``() =
             let doc = BsonDocument([ BsonElement("_t", BsonString "One")
                                      BsonElement("Item", BsonInt32 1) ])
 
-            let result = <@ deserialize doc typeof<Number> @>
+            let result = deserialize doc typeof<Number>
             let expected = One 1
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test serialize a union case with arity 2``() =
             let value = Two (1, 2)
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "Two")
                                           BsonElement("Item1", BsonInt32 1)
                                           BsonElement("Item2", BsonInt32 2) ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a union case with arity 2``() =
@@ -119,22 +119,22 @@ module FSharpUnionSerialization =
                                      BsonElement("Item1", BsonInt32 1)
                                      BsonElement("Item2", BsonInt32 2) ])
 
-            let result = <@ deserialize doc typeof<Number> @>
+            let result = deserialize doc typeof<Number>
             let expected = Two (1, 2)
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test serialize a union case with arity 3``() =
             let value = Three (1, 2, 3)
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "Three")
                                           BsonElement("Item1", BsonInt32 1)
                                           BsonElement("Item2", BsonInt32 2)
                                           BsonElement("Item3", BsonInt32 3) ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a union case with arity 3``() =
@@ -143,10 +143,10 @@ module FSharpUnionSerialization =
                                      BsonElement("Item2", BsonInt32 2)
                                      BsonElement("Item3", BsonInt32 3) ])
 
-            let result = <@ deserialize doc typeof<Number> @>
+            let result = deserialize doc typeof<Number>
             let expected = Three (1, 2, 3)
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
     module NullUnion =
 
@@ -163,8 +163,8 @@ module FSharpUnionSerialization =
               (C, BsonDocument([ BsonElement("_t", BsonString "C") ]))
               (D, BsonDocument([ BsonElement("_t", BsonString "D") ])) ]
             |> List.iter (fun (value, expected) ->
-                let result = <@ serialize value @>
-                test <@ %result = expected @>)
+                let result = serialize value
+                result |> should equal expected)
 
         [<Test>]
         let ``test deserialize a null union case``() =
@@ -173,8 +173,8 @@ module FSharpUnionSerialization =
               (C, BsonDocument([ BsonElement("_t", BsonString "C") ]))
               (D, BsonDocument([ BsonElement("_t", BsonString "D") ])) ]
             |> List.iter (fun (expected, doc) ->
-                let result = <@ deserialize doc typeof<Letter> @>
-                test <@ %result = expected @>)
+                let result = deserialize doc typeof<Letter>
+                result |> should equal expected)
 
     module Singleton =
 
@@ -194,50 +194,50 @@ module FSharpUnionSerialization =
         let ``test serialize a singleton union type with arity 0``() =
             let value = Only0.Case
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "Case") ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a singleton union type with arity 0``() =
             let doc = BsonDocument([ BsonElement("_t", BsonString "Case") ])
 
-            let result = <@ deserialize doc typeof<Only0> @>
+            let result = deserialize doc typeof<Only0>
             let expected = Only0.Case
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test serialize a singleton union type with arity 1``() =
             let value = Only1.Case 1
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "Case")
                                           BsonElement("Item", BsonInt32 1) ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a singleton union type with arity 1``() =
             let doc = BsonDocument([ BsonElement("_t", BsonString "Case")
                                      BsonElement("Item", BsonInt32 1) ])
 
-            let result = <@ deserialize doc typeof<Only1> @>
+            let result = deserialize doc typeof<Only1>
             let expected = Only1.Case 1
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test serialize a singleton union type with arity 2``() =
             let value = Only2.Case (1, 2)
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "Case")
                                           BsonElement("Item1", BsonInt32 1)
                                           BsonElement("Item2", BsonInt32 2) ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a singleton union type with arity 2``() =
@@ -245,22 +245,22 @@ module FSharpUnionSerialization =
                                      BsonElement("Item1", BsonInt32 1)
                                      BsonElement("Item2", BsonInt32 2) ])
 
-            let result = <@ deserialize doc typeof<Only2> @>
+            let result = deserialize doc typeof<Only2>
             let expected = Only2.Case (1, 2)
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test serialize a singleton union type with arity 3``() =
             let value = Only3.Case (1, 2, 3)
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "Case")
                                           BsonElement("Item1", BsonInt32 1)
                                           BsonElement("Item2", BsonInt32 2)
                                           BsonElement("Item3", BsonInt32 3) ])
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize a singleton union type with arity 3``() =
@@ -269,10 +269,10 @@ module FSharpUnionSerialization =
                                      BsonElement("Item2", BsonInt32 2)
                                      BsonElement("Item3", BsonInt32 3) ])
 
-            let result = <@ deserialize doc typeof<Only3> @>
+            let result = deserialize doc typeof<Only3>
             let expected = Only3.Case (1, 2, 3)
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
     module BindingFlags =
 
@@ -284,36 +284,35 @@ module FSharpUnionSerialization =
         let ``test serialize an internal null union case``() =
             let value = Null
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument("_t", BsonString "Null")
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize an internal null union case``() =
             let doc = BsonDocument("_t", BsonString "Null")
 
-            let result = <@ deserialize doc typeof<InternalUnion> @>
+            let result = deserialize doc typeof<InternalUnion>
             let expected = Null
 
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test serialize an internal non-null union case``() =
             let value = NonNull 0
 
-            let result = <@ serialize value @>
+            let result = serialize value
             let expected = BsonDocument([ BsonElement("_t", BsonString "NonNull")
                                           BsonElement("Item", BsonInt32 0) ])
-
-            test <@ %result = expected @>
+            result |> should equal expected
 
         [<Test>]
         let ``test deserialize an internal non-null union case``() =
             let doc = BsonDocument([ BsonElement("_t", BsonString "NonNull")
                                      BsonElement("Item", BsonInt32 1) ])
 
-            let result = <@ deserialize doc typeof<InternalUnion> @>
+            let result = deserialize doc typeof<InternalUnion>
             let expected = NonNull 1
 
-            test <@ %result = expected @>
+            result |> should equal expected