Add null-source and related tests for all other TaskSeq functions

abelbraaksma · abelbraaksma · commit 713220081218 · 2022-12-11T22:50:52.000+01:00
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.ExactlyOne.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.ExactlyOne.Tests.fs
@@ -13,6 +13,11 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.exactlyOne null
+        assertNullArg <| fun () -> TaskSeq.tryExactlyOne null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-exactlyOne throws`` variant = task {
         fun () ->
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Except.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Except.Tests.fs
@@ -14,6 +14,20 @@ open FSharp.Control
 
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.except null TaskSeq.empty
+        assertNullArg <| fun () -> TaskSeq.except TaskSeq.empty null
+        assertNullArg <| fun () -> TaskSeq.except null null
+
+        assertNullArg
+        <| fun () -> TaskSeq.exceptOfSeq null TaskSeq.empty
+
+        assertNullArg
+        <| fun () -> TaskSeq.exceptOfSeq Seq.empty null
+
+        assertNullArg <| fun () -> TaskSeq.exceptOfSeq null null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-except`` variant =
         Gen.getEmptyVariant variant
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Exists.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Exists.Tests.fs
@@ -12,6 +12,14 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg
+        <| fun () -> TaskSeq.exists (fun _ -> false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.existsAsync (fun _ -> Task.fromResult false) null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-exists returns false`` variant =
         Gen.getEmptyVariant variant
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Filter.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Filter.Tests.fs
@@ -14,6 +14,15 @@ open FSharp.Control
 
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg
+        <| fun () -> TaskSeq.filter (fun _ -> false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.filterAsync (fun _ -> Task.fromResult false) null
+
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-filter has no effect`` variant =
         Gen.getEmptyVariant variant
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Find.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Find.Tests.fs
@@ -15,6 +15,20 @@ open System.Collections.Generic
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg
+        <| fun () -> TaskSeq.find (fun _ -> false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.findAsync (fun _ -> Task.fromResult false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.tryFind (fun _ -> false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.tryFindAsync (fun _ -> Task.fromResult false) null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-find raises KeyNotFoundException`` variant =
         fun () ->
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.FindIndex.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.FindIndex.Tests.fs
@@ -15,6 +15,20 @@ open System.Collections.Generic
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg
+        <| fun () -> TaskSeq.findIndex (fun _ -> false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.findIndexAsync (fun _ -> Task.fromResult false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.tryFindIndex (fun _ -> false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.tryFindIndexAsync (fun _ -> Task.fromResult false) null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-findIndex raises KeyNotFoundException`` variant =
         fun () ->
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Fold.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Fold.Tests.fs
@@ -13,6 +13,14 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg
+        <| fun () -> TaskSeq.fold (fun _ _ -> 42) 0 null
+
+        assertNullArg
+        <| fun () -> TaskSeq.foldAsync (fun _ _ -> Task.fromResult 42) 0 null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-fold takes state when empty`` variant = task {
         let! empty =
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Head.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Head.Tests.fs
@@ -13,6 +13,10 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.head null
+        assertNullArg <| fun () -> TaskSeq.tryHead null
 
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-head throws`` variant = task {
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Indexed.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Indexed.Tests.fs
@@ -11,6 +11,9 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () = assertNullArg <| fun () -> TaskSeq.indexed null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-indexed on empty`` variant =
         Gen.getEmptyVariant variant
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.IsEmpty.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.IsEmpty.fs
@@ -7,7 +7,13 @@ open FsToolkit.ErrorHandling
 
 open FSharp.Control
 
+//
+// TaskSeq.isEmpty
+//
+
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () = assertNullArg <| fun () -> TaskSeq.head null
 
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-isEmpty returns true for empty`` variant =
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Item.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Item.Tests.fs
@@ -13,6 +13,11 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.item 42 null
+        assertNullArg <| fun () -> TaskSeq.tryItem 42 null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-item throws on empty sequences`` variant = task {
         fun () -> Gen.getEmptyVariant variant |> TaskSeq.item 0 |> Task.ignore
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Iter.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Iter.Tests.fs
@@ -13,6 +13,19 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.iter (fun _ -> ()) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.iteri (fun _ _ -> ()) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.iterAsync (fun _ -> Task.fromResult ()) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.iteriAsync (fun _ _ -> Task.fromResult ()) null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-iteri does nothing on empty sequences`` variant = task {
         let tq = Gen.getEmptyVariant variant
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Last.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Last.Tests.fs
@@ -13,6 +13,10 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.last null
+        assertNullArg <| fun () -> TaskSeq.tryLast null
 
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-last throws`` variant = task {
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Length.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Length.Tests.fs
@@ -14,6 +14,16 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.length null
+
+        assertNullArg
+        <| fun () -> TaskSeq.lengthBy (fun _ -> false) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.lengthByAsync (fun _ -> Task.fromResult false) null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-length returns zero on empty sequences`` variant = task {
         let! len = Gen.getEmptyVariant variant |> TaskSeq.length
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Map.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Map.Tests.fs
@@ -35,6 +35,17 @@ let validateSequenceWithOffset offset ts =
     |> Task.map (should equal expected)
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.map (fun _ -> ()) null
+        assertNullArg <| fun () -> TaskSeq.mapi (fun _ _ -> ()) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.mapAsync (fun _ -> Task.fromResult ()) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.mapiAsync (fun _ _ -> Task.fromResult ()) null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-map empty`` variant =
         Gen.getEmptyVariant variant
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.OfXXX.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.OfXXX.Tests.fs
@@ -11,6 +11,17 @@ let validateSequence sq =
     |> Task.map (Seq.toArray >> should equal [| 0..9 |])
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        // note: ofList and its variants do not have null as proper value
+        assertNullArg <| fun () -> TaskSeq.ofAsyncArray null
+        assertNullArg <| fun () -> TaskSeq.ofAsyncSeq null
+        assertNullArg <| fun () -> TaskSeq.ofTaskArray null
+        assertNullArg <| fun () -> TaskSeq.ofTaskSeq null
+        assertNullArg <| fun () -> TaskSeq.ofResizeArray null
+        assertNullArg <| fun () -> TaskSeq.ofArray null
+        assertNullArg <| fun () -> TaskSeq.ofSeq null
+
     [<Fact>]
     let ``TaskSeq-ofAsyncArray with empty set`` () =
         Array.init 0 (fun x -> async { return x })
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Pick.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Pick.Tests.fs
@@ -21,11 +21,22 @@ let pickerAsync equalTo x = task { return if x = equalTo then Some x else None }
 
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.pick (picker 0) null
+        assertNullArg <| fun () -> TaskSeq.tryPick (picker 0) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.pickAsync (pickerAsync 0) null
+
+        assertNullArg
+        <| fun () -> TaskSeq.tryPickAsync (pickerAsync 0) null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-pick on an empty sequence raises KeyNotFoundException`` variant = task {
         fun () ->
             Gen.getEmptyVariant variant
-            |> TaskSeq.pick (fun x -> if x = 12 then Some x else None)
+            |> TaskSeq.pick (picker 12)
             |> Task.ignore
         |> should throwAsyncExact typeof<KeyNotFoundException>
     }
@@ -34,16 +45,14 @@ module EmptySeq =
     let ``TaskSeq-pickAsync on an empty sequence raises KeyNotFoundException`` variant = task {
         fun () ->
             Gen.getEmptyVariant variant
-            |> TaskSeq.pickAsync (fun x -> task { return if x = 12 then Some x else None })
+            |> TaskSeq.pickAsync (pickerAsync 12)
             |> Task.ignore
         |> should throwAsyncExact typeof<KeyNotFoundException>
     }
 
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-tryPick on an empty sequence returns None`` variant = task {
-        let! nothing =
-            Gen.getEmptyVariant variant
-            |> TaskSeq.tryPick (fun x -> if x = 12 then Some x else None)
+        let! nothing = Gen.getEmptyVariant variant |> TaskSeq.tryPick (picker 12)
 
         nothing |> should be None'
     }
@@ -52,7 +61,7 @@ module EmptySeq =
     let ``TaskSeq-tryPickAsync on an empty sequence returns None`` variant = task {
         let! nothing =
             Gen.getEmptyVariant variant
-            |> TaskSeq.tryPickAsync (fun x -> task { return if x = 12 then Some x else None })
+            |> TaskSeq.tryPickAsync (pickerAsync 12)
 
         nothing |> should be None'
     }
@@ -63,7 +72,7 @@ module Immutable =
     let ``TaskSeq-pick sad path raises KeyNotFoundException`` variant = task {
         fun () ->
             Gen.getSeqImmutable variant
-            |> TaskSeq.pick (fun x -> if x = 0 then Some x else None) // dummy tasks sequence starts at 1
+            |> TaskSeq.pick (picker 0) // dummy tasks sequence starts at 1
             |> Task.ignore
 
         |> should throwAsyncExact typeof<KeyNotFoundException>
@@ -83,7 +92,7 @@ module Immutable =
     let ``TaskSeq-pick sad path raises KeyNotFoundException variant`` variant = task {
         fun () ->
             Gen.getSeqImmutable variant
-            |> TaskSeq.pick (fun x -> if x = 11 then Some x else None) // dummy tasks sequence ends at 50
+            |> TaskSeq.pick (picker 11) // dummy tasks sequence ends at 50
             |> Task.ignore
 
         |> should throwAsyncExact typeof<KeyNotFoundException>
@@ -93,7 +102,7 @@ module Immutable =
     let ``TaskSeq-pickAsync sad path raises KeyNotFoundException variant`` variant = task {
         fun () ->
             Gen.getSeqImmutable variant
-            |> TaskSeq.pickAsync (fun x -> task { return if x = 11 then Some x else None }) // dummy tasks sequence ends at 50
+            |> TaskSeq.pickAsync (pickerAsync 11) // dummy tasks sequence ends at 50
             |> Task.ignore
 
         |> should throwAsyncExact typeof<KeyNotFoundException>
@@ -164,9 +173,7 @@ module Immutable =
 
     [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
     let ``TaskSeq-tryPick sad path returns None`` variant = task {
-        let! nothing =
-            Gen.getSeqImmutable variant
-            |> TaskSeq.tryPick (fun x -> if x = 0 then Some x else None) // dummy tasks sequence starts at 1
+        let! nothing = Gen.getSeqImmutable variant |> TaskSeq.tryPick (picker 0) // dummy tasks sequence starts at 1
 
         nothing |> should be None'
     }
@@ -175,7 +182,7 @@ module Immutable =
     let ``TaskSeq-tryPickAsync sad path return None`` variant = task {
         let! nothing =
             Gen.getSeqImmutable variant
-            |> TaskSeq.tryPickAsync (fun x -> task { return if x = 0 then Some x else None }) // dummy tasks sequence starts at 1
+            |> TaskSeq.tryPickAsync (pickerAsync 0) // dummy tasks sequence starts at 1
 
         nothing |> should be None'
     }
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Tail.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Tail.Tests.fs
@@ -13,6 +13,10 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.tail null
+        assertNullArg <| fun () -> TaskSeq.tryTail null
 
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-tail throws`` variant = task {
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Tests.CE.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Tests.CE.fs
@@ -1,11 +1,24 @@
 module TaskSeq.Tests.``taskSeq Computation Expression``
 
+open System
+
 open Xunit
 open FsUnit.Xunit
 open FsToolkit.ErrorHandling
 
 open FSharp.Control
 
+[<Fact>]
+let ``CE taskSeq using yield! with null`` () = task {
+    let ts = taskSeq {
+        yield! Gen.sideEffectTaskSeq 10
+        yield! (null: taskSeq<int>)
+    }
+
+    fun () -> TaskSeq.toList ts
+    |> assertThrows typeof<NullReferenceException>
+}
+
 [<Fact>]
 let ``CE taskSeq with several yield!`` () = task {
     let tskSeq = taskSeq {
diff --git a/src/FSharp.Control.TaskSeq.Test/TaskSeq.Zip.Tests.fs b/src/FSharp.Control.TaskSeq.Test/TaskSeq.Zip.Tests.fs
@@ -12,6 +12,12 @@ open FSharp.Control
 //
 
 module EmptySeq =
+    [<Fact>]
+    let ``Null source is invalid`` () =
+        assertNullArg <| fun () -> TaskSeq.zip null TaskSeq.empty
+        assertNullArg <| fun () -> TaskSeq.zip TaskSeq.empty null
+        assertNullArg <| fun () -> TaskSeq.zip null null
+
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-zip can zip empty sequences v1`` variant =
         TaskSeq.zip (Gen.getEmptyVariant variant) (Gen.getEmptyVariant variant)
diff --git a/src/FSharp.Control.TaskSeq/TaskSeqInternal.fs b/src/FSharp.Control.TaskSeq/TaskSeqInternal.fs
