FSharp.Control.TaskSeq/src/FSharp.Control.TaskSeq.Test/TaskSeq.Append.Tests.fs at 32c57b37f8e11fa0b1947b098ff64680ac915d9d · 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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
module TaskSeq.Tests.Append

open Xunit
open FsUnit.Xunit

open FSharp.Control

//
// TaskSeq.append
// TaskSeq.appendSeq
// TaskSeq.prependSeq
//

let validateSequence ts =
    ts
    |> TaskSeq.toListAsync
    |> Task.map (List.map string)
    |> Task.map (String.concat "")
    |> Task.map (should equal "1234567891012345678910")


module EmptySeq =
    [<Fact>]
    let ``Null source is invalid`` () =
        assertNullArg
        <| fun () -> TaskSeq.empty |> TaskSeq.append null

        assertNullArg
        <| fun () -> null |> TaskSeq.append TaskSeq.empty

        assertNullArg <| fun () -> null |> TaskSeq.append null

    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
    let ``TaskSeq-append both args empty`` variant =
        Gen.getEmptyVariant variant
        |> TaskSeq.append (Gen.getEmptyVariant variant)
        |> verifyEmpty

    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
    let ``TaskSeq-appendSeq both args empty`` variant =
        Seq.empty
        |> TaskSeq.appendSeq (Gen.getEmptyVariant variant)
        |> verifyEmpty

    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
    let ``TaskSeq-prependSeq both args empty`` variant =
        Gen.getEmptyVariant variant
        |> TaskSeq.prependSeq Seq.empty
        |> verifyEmpty

module Immutable =
    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-append`` variant =
        Gen.getSeqImmutable variant
        |> TaskSeq.append (Gen.getSeqImmutable variant)
        |> validateSequence

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-appendSeq with a list`` variant =
        [ 1..10 ]
        |> TaskSeq.appendSeq (Gen.getSeqImmutable variant)
        |> validateSequence

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-appendSeq with an array`` variant =
        [| 1..10 |]
        |> TaskSeq.appendSeq (Gen.getSeqImmutable variant)
        |> validateSequence

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-prependSeq with a list`` variant =
        Gen.getSeqImmutable variant
        |> TaskSeq.prependSeq [ 1..10 ]
        |> validateSequence

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-prependSeq with an array`` variant =
        Gen.getSeqImmutable variant
        |> TaskSeq.prependSeq [| 1..10 |]
        |> validateSequence

module SideEffects =
    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-append consumes whole sequence once incl after-effects`` variant =
        let mutable i = 0

        taskSeq {
            i <- i + 1
            yield! [ 1..10 ]
            i <- i + 1
        }
        |> TaskSeq.append (Gen.getSeqImmutable variant)
        |> validateSequence
        |> Task.map (fun () -> i |> should equal 2)

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-appendSeq consumes whole sequence once incl after-effects`` variant =
        let mutable i = 0

        let ts = taskSeq {
            i <- i + 1
            yield! [ 1..10 ]
            i <- i + 1
        }

        [| 1..10 |]
        |> TaskSeq.appendSeq ts
        |> validateSequence
        |> Task.map (fun () -> i |> should equal 2)

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-prependSeq consumes whole sequence once incl after-effects`` variant =
        let mutable i = 0

        taskSeq {
            i <- i + 1
            yield! [ 1..10 ]
            i <- i + 1
        }
        |> TaskSeq.prependSeq [ 1..10 ]
        |> validateSequence
        |> Task.map (fun () -> i |> should equal 2)