public async ValueTask <int> Hyperlinq_AsyncEnumerable_Value()
        {
            var sum = 0;

            await foreach (var item in AsyncEnumerableExtensions
                           .AsAsyncValueEnumerable <TestAsyncEnumerable.AsyncEnumerable, TestAsyncEnumerable.AsyncEnumerable.AsyncEnumerator, int>(asyncEnumerableValue, (enumerable, cancellationToken) => enumerable.GetAsyncEnumerator(cancellationToken))
                           .Where((item, _) => new ValueTask <bool>((item & 0x01) == 0)))
            {
                sum += item;
            }
            return(sum);
        }
        public void AsAsyncValueEnumerable_GetEnumerator_With_ValidData_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsAsyncEnumerable(source);

            // Act
            var result = AsyncEnumerableExtensions
                         .AsAsyncValueEnumerable <Wrap.AsyncEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, (enumerable, _) => enumerable.GetAsyncEnumerator());

            // Assert
            _ = result.Must()
                .BeAsyncEnumerableOf <int>()
                .BeEqualTo(source);
        }
        public void AsAsyncValueEnumerable_With_ValidData_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsAsyncEnumerable(source);

            // Act
            var result = AsyncEnumerableExtensions
                         .AsAsyncValueEnumerable(wrapped);

            // Assert
            _ = result.Must()
                .BeAsyncEnumerableOf <int>()
                .BeEqualTo(source);
        }
        public async ValueTask AsAsyncValueEnumerable_With_ToArrayAsync_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsAsyncEnumerable(source);
            var expected = Enumerable
                           .ToArray(source);

            // Act
            var result = await AsyncEnumerableExtensions
                         .AsAsyncValueEnumerable <int>(wrapped)
                         .ToArrayAsync();

            // Assert
            _ = result.Must()
                .BeArrayOf <int>()
                .BeEqualTo(expected);
        }
Beispiel #5
0
        public async ValueTask ToListAsync_With_ValidData_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsAsyncEnumerable(source);
            var expected = Enumerable
                           .ToList(source);

            // Act
            var result = await AsyncEnumerableExtensions
                         .AsAsyncValueEnumerable(wrapped)
                         .ToListAsync();

            // Assert
            _ = result.Must()
                .BeOfType <List <int> >()
                .BeEnumerableOf <int>()
                .BeEqualTo(expected);
        }
 public ValueTask <int[]> Hyperlinq_AsyncEnumerable_Value() =>
 AsyncEnumerableExtensions.AsAsyncValueEnumerable <TestAsyncEnumerable.AsyncEnumerable, TestAsyncEnumerable.AsyncEnumerable.AsyncEnumerator, int>(
     asyncEnumerableValue,
     (enumerable, cancellationToken) => enumerable.GetAsyncEnumerator(cancellationToken))
 .ToArrayAsync();