FSharp.Control.TaskSeq/src/FSharp.Control.TaskSeq.Test/TaskSeq.Do.Tests.fs at fb986ef93866d39a64e8270a9a32c815b83f0c20 · 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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
module TaskSeq.Tests.Do

open System
open System.Threading.Tasks
open FsUnit
open Xunit

open FSharp.Control

[<Fact>]
let ``CE taskSeq: use 'do'`` () =
    let mutable value = 0

    taskSeq { do value <- value + 1 } |> verifyEmpty

[<Fact>]
let ``CE taskSeq: use 'do!' with a task<unit>`` () =
    let mutable value = 0

    taskSeq { do! task { do value <- value + 1 } }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 1)

[<Fact>]
let ``CE taskSeq: use 'do!' with a valuetask<unit>`` () =
    let mutable value = 0

    taskSeq { do! ValueTask.ofTask (task { do value <- value + 1 }) }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 1)

[<Fact>]
let ``CE taskSeq: use 'do!' with a non-generic valuetask`` () =
    let mutable value = 0

    taskSeq { do! ValueTask(task { do value <- value + 1 }) }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 1)

[<Fact>]
let ``CE taskSeq: use 'do!' with a non-generic task`` () =
    let mutable value = 0

    taskSeq { do! task { do value <- value + 1 } |> Task.ignore }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 1)

[<Fact>]
let ``CE taskSeq: use 'do!' with a task-delay`` () =
    let mutable value = 0

    taskSeq {
        do value <- value + 1
        do! Task.Delay 50
        do value <- value + 1
    }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 2)

[<Fact>]
let ``CE taskSeq: use 'do!' with Async`` () =
    let mutable value = 0

    taskSeq {
        do value <- value + 1
        do! Async.Sleep 50
        do value <- value + 1
    }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 2)

[<Fact>]
let ``CE taskSeq: use 'do!' with Async - mutables`` () =
    let mutable value = 0

    taskSeq {
        do! async { value <- value + 1 }
        do! Async.Sleep 50
        do! async { value <- value + 1 }
    }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 2)

[<Fact>]
let ``CE taskSeq: use 'do!' with all kinds of overloads at once`` () =
    let mutable value = 0

    // this test should be expanded in case any new overload is added
    // that is supported by `do!`, to ensure the high/low priority
    // overloads still work properly
    taskSeq {
        do! task { do value <- value + 1 } |> Task.ignore
        do! ValueTask <| task { do value <- value + 1 }
        do! ValueTask.ofTask (task { do value <- value + 1 })
        do! ValueTask<_>(()) // unit valuetask that completes immediately
        do! Task.fromResult (()) // unit Task that completes immediately
        do! Task.Delay 0
        do! Async.Sleep 0
        do! async { value <- value + 1 } // eq 4
    }
    |> verifyEmpty
    |> Task.map (fun _ -> value |> should equal 4)