public async void AssertResultSet_List()
{
await AsyncEnum.FromArray(new List <int>(new [] { 1, 2, 3 }))
.AssertResultSet(
ListComparer <int> .Default,
new List <int>(new[] { 1, 2, 3 }));
}
public void TestGroupByException()
{
var srcAsync = AsyncEnum.Enumerate <int>(async consumer =>
{
await consumer.YieldAsync(1);
throw new TestUtils.SomeTestException();
});
var asyncGroupsEnum = srcAsync.GroupBy(x => x).GetEnumerator();
Assert.IsTrue(asyncGroupsEnum.MoveNextAsync().AwaitSynchronously());
var asyncGroup1Enum = asyncGroupsEnum.Current.GetEnumerator();
try
{
asyncGroupsEnum.MoveNextAsync().AwaitSynchronously();
Assert.Fail();
}
catch (TestUtils.SomeTestException)
{ }
Assert.IsTrue(asyncGroup1Enum.MoveNextAsync().AwaitSynchronously());
Assert.AreEqual(1, asyncGroup1Enum.Current);
try
{
asyncGroup1Enum.MoveNextAsync().AwaitSynchronously();
Assert.Fail();
}
catch (TestUtils.SomeTestException)
{ }
}
public async void Take_EmitLatest()
{
await AsyncEnum.Interval(1, 5, TimeSpan.FromMilliseconds(200))
.Throttle(TimeSpan.FromMilliseconds(100), true)
.Take(1)
.AssertResult(1L);
}
public async void Solo()
{
await AsyncEnum.MergeConcurrently(
AsyncEnumerable.Range(1, 5)
)
.AssertResult(1, 2, 3, 4, 5);
}
public void TestMultithreadedFeed()
{
IEnumerable <IEnumerable <Tuple <object, int> > > expectedItemGroups = null;
var items = AsyncEnum.Enumerate <Tuple <object, int> >(async consumer =>
{
List <Task <IEnumerable <Tuple <object, int> > > > tasks = new List <Task <IEnumerable <Tuple <object, int> > > >();
for (int i = 0; i < 10; i++)
{
tasks.Add(Task.Factory.StartNew(threadIdx =>
{
List <Tuple <object, int> > threadItems = new List <Tuple <object, int> >();
for (int j = 0; j < 1000; j++)
{
var item = Tuple.Create(threadIdx, j);
consumer.YieldAsync(item);
threadItems.Add(item);
}
return((IEnumerable <Tuple <object, int> >)threadItems);
}, i));
}
expectedItemGroups = await Task.WhenAll(tasks);
});
var actualItems = items.ToList();
var match = from actualItem in actualItems
group actualItem by actualItem.Item1 into actualGroup
join expectedItemGroup in expectedItemGroups on actualGroup.Key equals expectedItemGroup.First().Item1
select new { Actual = actualGroup, Expected = expectedItemGroup };
Assert.IsTrue(match.All(x => x.Actual.SequenceEqual(x.Expected)));
}
public async void Timer()
{
await AsyncEnumerable.Range(1, 10)
.FlatMap(v => AsyncEnum.Timer(TimeSpan.FromMilliseconds(100)))
.Take(5)
.AssertResult(0L, 0L, 0L, 0L, 0L);
}
public static IAsyncEnumerable <T> GetFailingEnumerator <T>()
{
return(AsyncEnum.Enumerate <T>(async consumer =>
{
throw new SomeTestException();
}));
}
public async void Push()
{
for (var i = 0; i < 10; i++)
{
var push = new MulticastAsyncEnumerable <int>();
var en = AsyncEnum.MergeConcurrently(
push.Where(v => v % 2 == 0),
push.Where(v => v % 2 != 0)
)
.ToListAsync();
var t = Task.Run(async() =>
{
for (var j = 0; j < 100_000; j++)
{
await push.Next(j);
}
await push.Complete();
});
var list = await en;
await t;
var set = new HashSet <int>(list);
Assert.Equal(100_000, set.Count);
}
}
public async void Error()
{
await AsyncEnum.MergeConcurrently(
AsyncEnumerable.Range(1, 5),
AsyncEnum.Error <int>(new InvalidOperationException())
)
.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5);
}
public async void Normal_Uneven_2()
{
await AsyncEnum.MergeConcurrently(
AsyncEnumerable.Range(1, 4),
AsyncEnumerable.Range(6, 5)
)
.AssertResultSet(1, 2, 3, 4, 6, 7, 8, 9, 10);
}
public async Task PushToUnlimitedQueue()
{
var asyncEnum = AsyncEnum.Range(0, 10);
var queue = new Queue <int>();
await asyncEnum.PushToQueue(queue).LastAsync();
Assert.Equal(10, queue.Count);
}
public async Task PushToUnlimitedList()
{
var asyncEnum = AsyncEnum.Range(0, 10);
var list = new List <int>();
await asyncEnum.PushToList(list).LastAsync();
Assert.Equal(10, list.Count);
}
public async void Take()
{
await AsyncEnum.MergeConcurrently(
AsyncEnum.Timer(TimeSpan.FromMilliseconds(100)),
AsyncEnum.Timer(TimeSpan.FromMilliseconds(200))
)
.Take(1)
.AssertResult(0L);
}
public async Task PushToLimitedList()
{
var asyncEnum = AsyncEnum.Range(0, 10);
var list = new List <int>();
await asyncEnum.PushToList(list, 5).LastAsync();
Assert.Equal(5, list.Count);
Assert.Equal(5, list.First());
Assert.Equal(9, list.Last());
}
public static IAsyncEnumerable <T> EnumerateNothingForever <T>()
{
return(AsyncEnum.Enumerate <T>(async consumer =>
{
while (true)
{
await Task.Delay(TimeSpan.FromHours(1));
}
}));
}
public static IAsyncEnumerable <T> EnumerateWithDelay <T>(IEnumerable <T> source, int delayMs)
{
return(AsyncEnum.Enumerate <T>(async consumer =>
{
foreach (T item in source)
{
await Task.Delay(delayMs);
await consumer.YieldAsync(item);
}
}));
}
public async void Delayed_Completion_After_Debounced_Item()
{
await AsyncEnum.Just(1)
.ConcatWith(
AsyncEnum.Timer(TimeSpan.FromMilliseconds(200))
.Select(v => 0)
.IgnoreElements()
)
.Throttle(TimeSpan.FromMilliseconds(100))
.AssertResult(1);
}
public void TestEmpty()
{
var lookup = AsyncLookup <int, int> .ToLookup(AsyncEnum.Empty <int>(), x => x, null);
Assert.IsFalse(lookup.ContainsAsync(1).AwaitSynchronously());
var seq = lookup.GetAsync(1).AwaitSynchronously();
Assert.IsNotNull(seq);
Assert.AreEqual(0L, seq.CountAsync().AwaitSynchronously());
}
public async IAsyncEnumerable <IAsyncEnumerable <int> > GetStreams()
{
for (int i = 0; i < NumberOfStreams; i++)
{
yield return(AsyncEnum.Range(0, NumberOfStreamItems));
await Task.Delay(1);
}
await Task.CompletedTask;
}
public async Task MergeConcurrentlyOf4Sources()
{
var firstStream = AsyncEnum.Just(1);
var secondStream = AsyncEnum.Just(2);
var thirdStream = AsyncEnum.Just(3);
var forthStream = AsyncEnum.Just(4);
var list = await firstStream.MergeConcurrently(secondStream, thirdStream, forthStream).ToListAsync();
Assert.True(list.Count == 4);
}
public async void Error()
{
var push = new MulticastAsyncEnumerable <int>();
var t1 = push.AssertFailure(typeof(InvalidOperationException));
var t2 = push.AssertFailure(typeof(InvalidOperationException));
await AsyncEnum.Error <int>(new InvalidOperationException())
.Consume(push);
await t1;
await t2;
}
public async void Keep_All_EmitLast()
{
var t = 100;
if (Environment.GetEnvironmentVariable("CI") != null)
{
t = 1000;
}
await AsyncEnum.Interval(1, 5, TimeSpan.FromMilliseconds(2 * t))
.Throttle(TimeSpan.FromMilliseconds(t), true)
.AssertResult(1, 2, 3, 4, 5);
}
public async void Async_Normal()
{
await
AsyncEnum.FromArray(
AsyncEnumerable.Range(1, 3),
AsyncEnumerable.Empty <int>(),
AsyncEnum.FromArray(4, 5, 6, 7),
AsyncEnumerable.Empty <int>(),
AsyncEnum.Just(8),
AsyncEnum.FromEnumerable(new[] { 9, 10 }),
AsyncEnumerable.Empty <int>()
)
.Merge()
.AssertResultSet(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
public async void Cancel()
{
var cts = new CancellationTokenSource();
var push = new UnicastAsyncEnumerable <long>();
var t = AsyncEnum.Timer(TimeSpan.FromMilliseconds(500))
.Consume(push, cts.Token);
await Task.Delay(100, cts.Token);
cts.Cancel();
await t;
}
public async Task StripStringMessageTest()
{
var content = "77";
var message = new MqttApplicationMessage
{
Payload = Encoding.UTF8.GetBytes(content)
};
var stream = AsyncEnum.Just(message);
var result = stream.FromTextValues <int>().Strip();
var testResult = await result.ToListAsync();
Assert.True(testResult.First().Content == 77);
}
public void MergeConcurrentlyOf4Sources_CalledInDispatcherThread()
{
AsyncContext.Run(async() =>
{
var threadId = Thread.CurrentThread.ManagedThreadId;
var firstStream = AsyncEnum.Just(1);
var secondStream = AsyncEnum.Just(2);
var thirdStream = AsyncEnum.Just(3);
var forthStream = AsyncEnum.Just(4);
var list = await firstStream.MergeConcurrently(secondStream, thirdStream, forthStream)
.Do(i => Assert.True(Thread.CurrentThread.ManagedThreadId == threadId)).ToListAsync();
Assert.True(list.Count == 4);
});
}
public async void OutOfOrder()
{
var t = 100;
if (Environment.GetEnvironmentVariable("CI") != null)
{
t = 1000;
}
var result = AsyncEnum.FromArray(
t, 3 * t, 2 * t, 0, 5 * t, 4 * t
)
.FlatMap(v => AsyncEnum.Timer(TimeSpan.FromMilliseconds(v)).Select(w => v))
;
await result.AssertResult(0, t, 2 *t, 3 *t, 4 *t, 5 *t);
}
public async Task Test2()
{
var stream = AsyncEnum.Range(0, 300000);
var stream2 = AsyncEnum.Range(0, 300000);
var streams = new[] { stream, stream2 };
var sw = Stopwatch.StartNew();
//stream = stream.If(i => i % 2 == 0, i => i.Select(o => o * 2));
//stream = stream.Select(i => i * 2).ToReplayQueue();
await foreach (var item in stream)
{
lock (this)
{
_otherQueue.OnNext(item);
}
//using (await _asyncLock.LockAsync())
{
//await _queue.Next(item);
}
}
await foreach (var item in stream2)
{
lock (this)
{
_otherQueue.OnNext(item);
}
//using (await _asyncLock.LockAsync())
{
//await _queue.Next(item);
}
}
//await _queue.Complete();
_otherQueue.OnCompleted();
//stream = AsyncEnumerableEx.Merge(streams);
//stream = streams.MergeSequential();
var result = await _otherQueue.ToAsyncEnumerable().ToListAsync();
sw.Stop();
}
public async Task StripJsonMessageTest()
{
var content = new TestContent()
{
Number = 77,
Text = "Huhu",
Time = DateTime.Now
};
var serializedContent = JsonConvert.SerializeObject(content);
var message = new MqttApplicationMessage
{
Payload = Encoding.UTF8.GetBytes(serializedContent)
};
var stream = AsyncEnum.Just(message);
var result = stream.FromJsonValues <TestContent>().Strip();
var testResult = await result.ToListAsync();
Assert.True(Equals(testResult.First().Content, content));
}
private async Task TestGroupByRandomAccessAsync()
{
Func <int, int> groupFunction = k => k % 10;
int n = 10000;
var rnd = new Random(0);
var src = Enumerable.Range(0, n).Select(x => rnd.Next(1000)).ToList();
var expectedGroups = src.GroupBy(groupFunction);
var expectedKeys = expectedGroups.Select(g => g.Key);
var asyncSrc = AsyncEnum.Enumerate <int>(async consumer =>
{
foreach (var srcItem in src)
{
//if (rnd.Next(10) == 0)
// await TaskEx.Delay(rnd.Next(10) * 10);
var awaitDemandTask = consumer.YieldAsync(srcItem);
if (rnd.Next(4) == 0)
{
await awaitDemandTask;
}
}
});
var asyncGroupsEnumerator =
asyncSrc.GroupBy(groupFunction).GetEnumerator();
var actualKeys = new List <int>();
var actualAsyncEnumerators = new List <IAsyncEnumerator <int> >();
var pendingAsyncEnumerators = new List <Tuple <List <int>, IAsyncEnumerator <int> > >();
var actualGroupValues = new List <List <int> >();
int foundValues = 0;
while (foundValues < n)
{
if ((pendingAsyncEnumerators.Count == 0) || (rnd.Next(2000) == 0))
{
if (await asyncGroupsEnumerator.MoveNextAsync())
{
actualKeys.Add(asyncGroupsEnumerator.Current.Key);
var innerAsyncEnumerator = asyncGroupsEnumerator.Current.GetEnumerator();
actualAsyncEnumerators.Add(innerAsyncEnumerator);
var values = new List <int>();
pendingAsyncEnumerators.Add(Tuple.Create(values, innerAsyncEnumerator));
actualGroupValues.Add(values);
}
}
else
{
int nextGroupIdx = rnd.Next(pendingAsyncEnumerators.Count);
var pendingGroup = pendingAsyncEnumerators[nextGroupIdx];
if (await pendingGroup.Item2.MoveNextAsync())
{
pendingGroup.Item1.Add(pendingGroup.Item2.Current);
foundValues++;
}
else
{
pendingAsyncEnumerators.RemoveAt(nextGroupIdx);
}
}
}
Assert.IsTrue(expectedKeys.SequenceEqual(actualKeys));
Assert.AreEqual(expectedGroups.Count(), actualGroupValues.Count);
foreach (var tuple in expectedGroups.Zip(actualGroupValues, Tuple.Create))
{
Assert.IsTrue(tuple.Item1.SequenceEqual(tuple.Item2));
}
}
