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 Solo()
 {
     await AsyncEnum.MergeConcurrently(
         AsyncEnumerable.Range(1, 5)
         )
     .AssertResult(1, 2, 3, 4, 5);
 }
 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 void Take()
 {
     await AsyncEnum.MergeConcurrently(
         AsyncEnum.Timer(TimeSpan.FromMilliseconds(100)),
         AsyncEnum.Timer(TimeSpan.FromMilliseconds(200))
         )
     .Take(1)
     .AssertResult(0L);
 }
 public async void Empty()
 {
     await AsyncEnum.MergeConcurrently <int>(
         )
     .AssertResult();
 }