protected void Initialize(int[] array)
        {
            this.array = array;
            memory     = array.AsMemory();

            enumerableReference      = enumerableValue = Wrap.AsEnumerable(array);
            collectionReference      = collectionValue = Wrap.AsCollection(array);
            listReference            = listValue = Wrap.AsList(array);
            asyncEnumerableReference = asyncEnumerableValue = Wrap.AsAsyncEnumerable(array);
        }
        public void ToArray_With_ValidData_Collections_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsCollection(source);
            var expected = Enumerable
                           .ToArray(source);

            // Act
            var result = ReadOnlyCollectionExtensions
                         .AsValueEnumerable(wrapped)
                         .ToArray();

            // Assert
            _ = result.Must()
                .BeArrayOf <int>()
                .BeEqualTo(expected);
        }
Example #3
0
        public void AsValueEnumerable_GetEnumerator_Collection_With_ToArray_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsCollection(source);
            var expected = Enumerable
                           .ToArray(source);

            // Act
            var result = ReadOnlyCollectionExtensions
                         .AsValueEnumerable <Wrap.CollectionWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, enumerable => enumerable.GetEnumerator())
                         .ToArray();

            // Assert
            _ = result.Must()
                .BeArrayOf <int>()
                .BeEqualTo(expected);
        }
Example #4
0
        public void ToList_With_ValidData_Collections_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsCollection(source);
            var expected = Enumerable
                           .ToList(source);

            // Act
            var result = EnumerableExtensions
                         .AsValueEnumerable <int>(wrapped)
                         .ToList();

            // Assert
            _ = result.Must()
                .BeOfType <List <int> >()
                .BeEnumerableOf <int>()
                .BeEqualTo(expected);
        }