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()));
}
