public void ToObservable_disposes_enumerator_on_completion()
{
var fail = false;
var evt = new ManualResetEvent(false);
var ae = AsyncEnumerable.CreateEnumerable(
() => AsyncEnumerable.CreateEnumerator <int>(
ct => Task.FromResult(false),
() => { throw new InvalidOperationException(); },
() => { evt.Set(); }));
ae
.ToObservable()
.Subscribe(new MyObserver <int>(
x =>
{
fail = true;
},
ex =>
{
fail = true;
},
() =>
{
}
));
evt.WaitOne();
Assert.False(fail);
}
public static IAsyncEnumerable <T> WithDispose <T>(this IAsyncEnumerable <T> source, Action a)
{
return(AsyncEnumerable.CreateEnumerable <T>(() =>
{
var e = source.GetEnumerator();
return AsyncEnumerable.CreateEnumerator <T>(e.MoveNext, () => e.Current, () => { e.Dispose(); a(); });
}));
}
public void ToObservable_does_not_call_MoveNext_again_when_subscription_is_disposed()
{
var fail = false;
var moveNextCount = 0;
var evt = new ManualResetEvent(false);
var subscription = default(IDisposable);
var subscriptionAssignedTcs = new TaskCompletionSource <object>();
var ae = AsyncEnumerable.CreateEnumerable(
() => AsyncEnumerable.CreateEnumerator(
async ct =>
{
await subscriptionAssignedTcs.Task;
moveNextCount++;
return(true);
},
() => 1,
() => { evt.Set(); }));
subscription = ae
.ToObservable()
.Subscribe(new MyObserver <int>(
x =>
{
subscription.Dispose();
},
ex =>
{
fail = true;
},
() =>
{
fail = true;
}
));
subscriptionAssignedTcs.SetResult(null);
evt.WaitOne();
Assert.Equal(1, moveNextCount);
Assert.False(fail);
}
public async Task CreateEnumerator_DisposeOnce()
{
var count = 0;
var dispose = 0;
var en = AsyncEnumerable.CreateEnumerable(() =>
AsyncEnumerable.CreateEnumerator(async ct =>
{
return(++count < 3);
}
, () => 1,
() => dispose++
));
Assert.Equal(1, await en.Last());
Assert.Equal(3, count);
Assert.Equal(1, dispose);
}
public void Create_Null()
{
AssertThrows <ArgumentNullException>(() => AsyncEnumerable.CreateEnumerable <int>(null));
AssertThrows <ArgumentNullException>(() => AsyncEnumerable.CreateEnumerator <int>(null, () => 3, () => {}));
}
