public async Task Empty() { var value = await AsyncObservable.Empty <int>().ToListAsync(); value .Should().HaveCount(0); }
public async Task ExceptionBefore() { string result = ""; var scheduler = new TestAsyncScheduler(); var catched = false; try { await AsyncObservable.Range(0, 5) .Do(i => result += i) .Do(i => { if (i == 2) { throw new TestException(); } }) .Prefetch() .Do(i => result += i) .SubscribeAsync() .ConfigureAwait(false); } catch (TestException) { catched = true; } catched .Should().BeTrue(); result .Should().Be("00112"); }
public async Task Count10() { var value = await AsyncObservable.Range(1, 10).FirstAsync(); value .Should().Be(1); }
public async Task IntermediateCancel() { var result = ""; var scheduler = new TestAsyncScheduler(); await scheduler.RunAsync(async() => { using (var cts = new CancellationTokenSource()) { var t1 = AsyncObservable.Range(0, 10) .Select(async(i, ca) => { await scheduler.Delay(20.Seconds(), ca); return(i); }) .SubscribeAsync(i => result += i, onCompleted: () => result += "C", ca: cts.Token); await scheduler.Delay(50.Seconds(), default); cts.Cancel(); await t1; } return(Unit.Default); }); result .Should().Be("01"); }
public async Task EmptyWithPredicate() { var value = await AsyncObservable.Empty <int>().AnyAsync(i => i > 4); value .Should().Be(false); }
public async Task Finally6() { string result = ""; bool rethrown = false; try { await AsyncObservable.Empty <int>() .Finally(() => { result += "1"; throw new Exception(); }) .Finally(() => { result += "2"; throw new Exception(); }) .SubscribeAsync(); } catch { rethrown = true; } rethrown .Should().Be(true); result .Should().Be("12"); }
public async Task Empty() { var value = await AsyncObservable.Empty <int>().AnyAsync(); value .Should().Be(false); }
public async Task Count10() { var value = await AsyncObservable.Range(0, 10).AnyAsync(); value .Should().Be(true); }
public async Task Count10WithPredicate2() { var value = await AsyncObservable.Range(0, 10).AnyAsync(i => i > 20); value .Should().Be(false); }
public void Count0() { Func <Task <int> > func = async() => await AsyncObservable.Empty <int>().FirstAsync(); func .Should().ThrowExactly <InvalidOperationException>(); }
public async Task Range() { var value = await AsyncObservable.Range(0, 10).ToListAsync(); value .Should().Equal(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); }
public async Task ConsumeSlowlySingle() { var scheduler = new TestAsyncScheduler(); var result = await scheduler.RunAsync(async() => { var inner = AsyncObservable.Range(0, 5); return(await new [] { inner } .ToAsyncObservable() .Merge() .ConsumeSlowly(scheduler, 10.Seconds(), 10.Seconds(), 10.Seconds(), 10.Seconds(), 10.Seconds())); }); result .Should().Equal( (0, 10.Seconds()), (1, 20.Seconds()), (2, 30.Seconds()), (3, 40.Seconds()), (4, 50.Seconds())); }
public async Task Empty() { var value = await AsyncObservable.Empty <int>().AllAsync(i => false); value .Should().Be(true); }
public void Throw() { Func <Task <bool> > func = async() => await AsyncObservable.Throw <int>(new NotImplementedException()).AllAsync(i => i < 0); func .Should().ThrowExactly <NotImplementedException>(); }
public async Task RangeTrue() { var value = await AsyncObservable.Range(0, 10).AllAsync(i => i < 20); value .Should().Be(true); }
public async Task RangeFalse() { var value = await AsyncObservable.Range(0, 10).AllAsync(i => i != 0); value .Should().Be(false); }
public async Task Count1() { var value = await AsyncObservable.Return(1).FirstAsync(); value .Should().Be(1); }
public void ThrowWithPredicate() { Func <Task <bool> > func = async() => await AsyncObservable.Throw <int>(new NotImplementedException()).AnyAsync(v => false); func .Should().ThrowExactly <NotImplementedException>(); }
public async Task Cancellation() { var result = ""; var value = await AsyncObservable.Range(1, 10).Do(i => result += i).FirstAsync(); result .Should().Be("1"); }
public void ArgumentExceptions() { Action action; action = () => AsyncObservable.ToAsyncObservable((IEnumerable <int>)null); action .Should().Throw <ArgumentNullException>(); }
static async Task SelectManyAsync() { var res = from i in AsyncObservable.Range(0, 10) from j in AsyncObservable.Range(i * 10, 10) select i + " -> " + j; await res.SubscribeAsync(Print <string>()); }
public async Task Already_Ordered() { var l = await AsyncObservable.Range(1, 5) .OrderBy(v => v) .ToListAsync(); l .Should().Equal(1, 2, 3, 4, 5); }
public static IAsyncObservable <TResult> ToAsyncObservable <TResult>(this Task <TResult> task) { if (task == null) { throw new ArgumentNullException(nameof(task)); } return(AsyncObservable.Create <TResult>(observer => task.AcceptAsync(observer))); }
public static IAsyncObservable <int> ProduceSlowly(this IAsyncScheduler scheduler, params TimeSpan[] delays) { return(AsyncObservable.Range(0, delays.Length) .Select(async(i, ca) => { await scheduler.Delay(delays[i], ca).ConfigureAwait(false); return i; })); }
static async Task BufferTimeHoppingAsync() { await AsyncObservable .Interval(TimeSpan.FromMilliseconds(300)) .Buffer(TimeSpan.FromSeconds(1)) .Select(xs => string.Join(", ", xs)) .SubscribeAsync(Print <string>()); // TODO: Use ForEachAsync. }
public async Task Inverse() { var l = await AsyncObservable.Range(1, 5) .OrderBy(v => - v) .ToListAsync(); l .Should().Equal(5, 4, 3, 2, 1); }
public async Task Return1() { string result = ""; await AsyncObservable.Return(1) .SubscribeAsync(i => result += i, ex => result += "E", () => result += "C"); result .Should().Be("1C"); }
static async Task CombineLatestAsync() { await AsyncObservable.CombineLatest( AsyncObservable.Interval(TimeSpan.FromMilliseconds(250)).Take(10).Timestamp(), AsyncObservable.Interval(TimeSpan.FromMilliseconds(333)).Take(10).Timestamp(), (x, y) => x.ToString() + ", " + y.ToString() ) .SubscribeAsync(Print <string>()); // TODO: Use ForEachAsync. }
static async Task BufferTimeSlidingAsync() { await AsyncObservable .Interval(TimeSpan.FromMilliseconds(100)) .Timestamp(TaskPoolAsyncScheduler.Default) .Buffer(TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(300)) .Select(xs => $"[{xs.First().Timestamp}, {xs.Last().Timestamp}] = {(xs.Last().Timestamp - xs.First().Timestamp).TotalMilliseconds}") .SubscribeAsync(Print <string>()); // TODO: Use ForEachAsync. }
static async Task GroupBySelectManyAsync() { await AsyncObservable.Interval(TimeSpan.FromMilliseconds(250)) .Timestamp() .Take(20) .GroupBy(t => t.Timestamp.Millisecond / 100) .SelectMany(g => g, (g, x) => g.Key + " - " + x) .SubscribeAsync(Print <string>()); }
public async Task Should_remain_in_order() { var values = new List<int>(); var observable = new AsyncObservable<List<int>>(); ConnectHandle observer = observable.Connect(values); for (int i = 0; i < 10000; i++) { int index = i; observable.Notify(async x => x.Add(index)); } observer.Disconnect(); Assert.AreEqual(10000, values.Count); Assert.IsTrue(values.SequenceEqual(Enumerable.Range(0, 10000).Select(x => x).ToList())); }