-
Notifications
You must be signed in to change notification settings - Fork 735
/
AsyncTests.Bugs.cs
202 lines (157 loc) · 5.85 KB
/
AsyncTests.Bugs.cs
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
namespace Tests
{
public partial class AsyncTests
{
public AsyncTests()
{
TaskScheduler.UnobservedTaskException += (o, e) =>
{
};
}
[Fact]
public async void CorrectDispose()
{
var disposed = new TaskCompletionSource<bool>();
var xs = new[] { 1, 2, 3 }.WithDispose(() =>
{
disposed.TrySetResult(true);
}).ToAsyncEnumerable();
var ys = xs.Select(x => x + 1);
var e = ys.GetAsyncEnumerator();
// We have to call move next because otherwise the internal enumerator is never allocated
await e.MoveNextAsync();
await e.DisposeAsync();
await disposed.Task;
Assert.True(await disposed.Task);
Assert.False(await e.MoveNextAsync());
var next = await e.MoveNextAsync();
Assert.False(next);
}
[Fact]
public async Task DisposesUponError()
{
var disposed = new TaskCompletionSource<bool>();
var xs = new[] { 1, 2, 3 }.WithDispose(() =>
{
disposed.SetResult(true);
}).ToAsyncEnumerable();
var ex = new Exception("Bang!");
var ys = xs.Select(x => { if (x == 1) throw ex; return x; });
var e = ys.GetAsyncEnumerator();
await AssertX.ThrowsAsync<Exception>(() => e.MoveNextAsync());
var result = await disposed.Task;
Assert.True(result);
}
[Fact]
public async Task TakeOneFromSelectMany()
{
var ret0 = new[] { 0 }.ToAsyncEnumerable();
var retCheck = new[] { "Check" }.ToAsyncEnumerable();
var enumerable =
ret0
.SelectMany(_ => retCheck)
.Take(1)
.Do(_ => { });
Assert.Equal("Check", await enumerable.FirstAsync());
}
[Fact]
public async Task SelectManyDisposeInvokedOnlyOnceAsync()
{
var disposeCounter = new DisposeCounter();
var result = await new[] { 1 }.ToAsyncEnumerable().SelectMany(i => disposeCounter).Select(i => i).ToListAsync();
Assert.Empty(result);
Assert.Equal(1, disposeCounter.DisposeCount);
}
[Fact]
public async Task SelectManyInnerDisposeAsync()
{
var disposes = Enumerable.Range(0, 10).Select(_ => new DisposeCounter()).ToList();
var result = await AsyncEnumerable.Range(0, 10).SelectMany(i => disposes[i]).Select(i => i).ToListAsync();
Assert.Empty(result);
Assert.True(disposes.All(d => d.DisposeCount == 1));
}
[Fact]
public void DisposeAfterCreation()
{
var enumerable = new[] { 1 }.ToAsyncEnumerable() as IDisposable;
enumerable?.Dispose();
}
private class DisposeCounter : IAsyncEnumerable<object?>
{
public int DisposeCount { get; private set; }
public IAsyncEnumerator<object?> GetAsyncEnumerator(CancellationToken cancellationToken)
{
return new Enumerator(this);
}
private class Enumerator : IAsyncEnumerator<object?>
{
private readonly DisposeCounter _disposeCounter;
public Enumerator(DisposeCounter disposeCounter)
{
_disposeCounter = disposeCounter;
}
public ValueTask DisposeAsync()
{
_disposeCounter.DisposeCount++;
return default;
}
public ValueTask<bool> MoveNextAsync()
{
return new ValueTask<bool>(Task.Factory.StartNew(() => false));
}
public object? Current { get; private set; }
}
}
}
internal static class MyExt
{
public static IEnumerable<T> WithDispose<T>(this IEnumerable<T> source, Action a)
{
return new Enumerable<T>(() =>
{
var e = source.GetEnumerator();
return new Enumerator<T>(e.MoveNext, () => e.Current, () => { e.Dispose(); a(); });
});
}
private sealed class Enumerable<T> : IEnumerable<T>
{
private readonly Func<IEnumerator<T>> _getEnumerator;
public Enumerable(Func<IEnumerator<T>> getEnumerator)
{
_getEnumerator = getEnumerator;
}
public IEnumerator<T> GetEnumerator() => _getEnumerator();
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
private sealed class Enumerator<T> : IEnumerator<T>
{
private readonly Func<bool> _moveNext;
private readonly Func<T> _current;
private readonly Action _dispose;
public Enumerator(Func<bool> moveNext, Func<T> current, Action dispose)
{
_moveNext = moveNext;
_current = current;
_dispose = dispose;
}
public T Current => _current();
public void Dispose() => _dispose();
object IEnumerator.Current => Current;
public bool MoveNext() => _moveNext();
public void Reset()
{
throw new NotImplementedException();
}
}
}
}