FSharp.Control.TaskSeq/src/FSharp.Control.TaskSeq.Test/TaskSeq.IsEmpty.fs at fab16e5a9df479be8905d1c5ea0a5c4356cbbfb4 · fsprojects/FSharp.Control.TaskSeq · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
module TaskSeq.Tests.IsEmpty

open Xunit
open FsUnit.Xunit

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 =
        Gen.getEmptyVariant variant
        |> TaskSeq.isEmpty
        |> Task.map (should be True)

module Immutable =
    [<Fact>]
    let ``TaskSeq-isEmpty returns false for singleton`` () =
        taskSeq { yield 42 }
        |> TaskSeq.isEmpty
        |> Task.map (should be False)

    [<Fact>]
    let ``TaskSeq-isEmpty returns false for delayed singleton sequence`` () =
        Gen.sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 3
        |> TaskSeq.isEmpty
        |> Task.map (should be False)

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-isEmpty returns false for non-empty`` variant =
        Gen.getSeqImmutable variant
        |> TaskSeq.isEmpty
        |> Task.map (should be False)

module SideEffects =
    [<Fact>]
    let ``TaskSeq-isEmpty prove that it won't execute side effects after the first item`` () =
        let mutable i = 0

        taskSeq {
            i <- i + 1
            yield 42
            i <- i + 1
        }
        |> TaskSeq.isEmpty
        |> Task.map (should be False)
        |> Task.map (fun () -> i |> should equal 1)

    [<Fact>]
    let ``TaskSeq-isEmpty prove that it does execute side effects if empty`` () =
        let mutable i = 0

        taskSeq {
            i <- i + 1
            i <- i + 1
        }
        |> TaskSeq.isEmpty
        |> Task.map (should be True)
        |> Task.map (fun () -> i |> should equal 2)

    [<Fact>]
    let ``TaskSeq-isEmpty executes side effects each time`` () =
        let mutable i = 0

        taskSeq {
            i <- i + 1
            i <- i + 1
        }
        |>> TaskSeq.isEmpty
        |>> TaskSeq.isEmpty
        |>> TaskSeq.isEmpty
        |> TaskSeq.isEmpty // 4th time: 8
        |> Task.map (should be True)
        |> Task.map (fun () -> i |> should equal 8)

    [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
    let ``TaskSeq-isEmpty returns false for non-empty`` variant =
        Gen.getSeqWithSideEffect variant
        |> TaskSeq.isEmpty
        |> Task.map (should be False)