FSharp.Control.TaskSeq/src/FSharp.Control.TaskSeq.Test/TaskSeq.Except.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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
module TaskSeq.Tests.Except

open Xunit
open FsUnit.Xunit

open FSharp.Control

//
// TaskSeq.except
// TaskSeq.exceptOfSeq
//


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
        |> TaskSeq.except (Gen.getEmptyVariant variant)
        |> verifyEmpty

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

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

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

    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
    let ``TaskSeq-except no side effect in exclude seq if source seq is empty`` variant =
        let mutable i = 0

        let exclude = taskSeq {
            i <- i + 1
            yield 12
        }

        TaskSeq.empty
        |> TaskSeq.except exclude
        |> verifyEmpty
        |> Task.map (fun () -> i |> should equal 0) // exclude seq is only enumerated after first item in source

module Immutable =
    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-except removes duplicates`` variant =
        TaskSeq.ofList [ 1; 1; 2; 3; 4; 12; 12; 12; 13; 13; 13; 13; 13; 99 ]
        |> TaskSeq.except (Gen.getSeqImmutable variant)
        |> TaskSeq.toArrayAsync
        |> Task.map (should equal [| 12; 13; 99 |])

    [<Fact>]
    let ``TaskSeq-except removes duplicates with empty itemsToExcept`` () =
        TaskSeq.ofList [ 1; 1; 2; 3; 4; 12; 12; 12; 13; 13; 13; 13; 13; 99 ]
        |> TaskSeq.except TaskSeq.empty
        |> TaskSeq.toArrayAsync
        |> Task.map (should equal [| 1; 2; 3; 4; 12; 13; 99 |])

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-except removes everything`` variant =
        Gen.getSeqImmutable variant
        |> TaskSeq.except (Gen.getSeqImmutable variant)
        |> verifyEmpty

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-except removes everything with duplicates`` variant =
        taskSeq {
            yield! Gen.getSeqImmutable variant
            yield! Gen.getSeqImmutable variant
            yield! Gen.getSeqImmutable variant
            yield! Gen.getSeqImmutable variant
        }
        |> TaskSeq.except (Gen.getSeqImmutable variant)
        |> verifyEmpty

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-exceptOfSeq removes duplicates`` variant =
        TaskSeq.ofList [ 1; 1; 2; 3; 4; 12; 12; 12; 13; 13; 13; 13; 13; 99 ]
        |> TaskSeq.exceptOfSeq [ 1..10 ]
        |> TaskSeq.toArrayAsync
        |> Task.map (should equal [| 12; 13; 99 |])

    [<Fact>]
    let ``TaskSeq-exceptOfSeq removes duplicates with empty itemsToExcept`` () =
        TaskSeq.ofList [ 1; 1; 2; 3; 4; 12; 12; 12; 13; 13; 13; 13; 13; 99 ]
        |> TaskSeq.exceptOfSeq Seq.empty
        |> TaskSeq.toArrayAsync
        |> Task.map (should equal [| 1; 2; 3; 4; 12; 13; 99 |])

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-exceptOfSeq removes everything`` variant =
        Gen.getSeqImmutable variant
        |> TaskSeq.exceptOfSeq [ 1..10 ]
        |> verifyEmpty

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-exceptOfSeq removes everything with duplicates`` variant =
        taskSeq {
            yield! Gen.getSeqImmutable variant
            yield! Gen.getSeqImmutable variant
            yield! Gen.getSeqImmutable variant
            yield! Gen.getSeqImmutable variant
        }
        |> TaskSeq.exceptOfSeq [ 1..10 ]
        |> verifyEmpty

module SideEffects =
    [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
    let ``TaskSeq-except removes duplicates`` variant =
        TaskSeq.ofList [ 1; 1; 2; 3; 4; 12; 12; 12; 13; 13; 13; 13; 13; 99 ]
        |> TaskSeq.except (Gen.getSeqWithSideEffect variant)
        |> TaskSeq.toArrayAsync
        |> Task.map (should equal [| 12; 13; 99 |])

    [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
    let ``TaskSeq-except removes everything`` variant =
        Gen.getSeqWithSideEffect variant
        |> TaskSeq.except (Gen.getSeqWithSideEffect variant)
        |> verifyEmpty

    [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
    let ``TaskSeq-except removes everything with duplicates`` variant =
        taskSeq {
            yield! Gen.getSeqWithSideEffect variant
            yield! Gen.getSeqWithSideEffect variant
            yield! Gen.getSeqWithSideEffect variant
            yield! Gen.getSeqWithSideEffect variant
        }
        |> TaskSeq.except (Gen.getSeqWithSideEffect variant)
        |> verifyEmpty