public void Single_Selector_With_Empty_Must_Return_None(int[] source, Selector <int, string> selector)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueReadOnlyCollection(source);

            // Act
            var result = ValueReadOnlyCollection
                         .Select <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
                         .Single();

            // Assert
            _ = result.Must()
                .BeOfType <Option <string> >()
                .EvaluateTrue(option => option.IsNone);
        }
        public void SelectIndex_With_ValidData_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped  = Wrap.AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.Select(wrapped, (item, index) => (item + index).ToString());

            // Act
            var result = ValueReadOnlyCollection
                         .Select <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int, string>(wrapped, (item, index) => (item + index).ToString());

            // Assert
            _ = result.Must()
                .BeEnumerableOf <string>()
                .BeEqualTo(expected);
        }
Beispiel #3
0
        public void Single_With_Single_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.Single(source);

            // Act
            var result = ValueReadOnlyCollection
                         .Single <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped);

            // Assert
            _ = result.Must()
                .BeEqualTo(expected);
        }
        public void Any_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
        {
            // Arrange
            var wrapped  = Wrap.AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.Count(
                    System.Linq.Enumerable.Where(source, predicate.AsFunc())) != 0;

            // Act
            var result = ValueReadOnlyCollection
                         .Any <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);

            // Assert
            _ = result.Must()
                .BeEqualTo(expected);
        }
        public void FirstOrDefault_With_ValidData_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.FirstOrDefault(source);

            // Act
            var result = ValueReadOnlyCollection
                         .FirstOrDefault <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped);

            // Assert
            _ = result.Must()
                .BeEqualTo(expected);
        }
        public void All_PredicateAt_With_NullPredicate_Must_Throw()
        {
            // Arrange
            var source    = new int[0];
            var wrapped   = Wrap.AsValueReadOnlyCollection(source);
            var predicate = (PredicateAt <int>)null;

            // Act
            Action action = () => _ = ValueReadOnlyCollection
                                      .All <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);

            // Assert
            _ = action.Must()
                .Throw <ArgumentNullException>()
                .EvaluateTrue(exception => exception.ParamName == "predicate");
        }
Beispiel #7
0
        public void Take_With_ValidData_Must_Succeed(int[] source, int count)
        {
            // Arrange
            var wrapped  = Wrap.AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.Take(wrapped, count);

            // Act
            var result = ValueReadOnlyCollection
                         .Take <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, count);

            // Assert
            _ = result.Must()
                .BeEnumerableOf <int>()
                .BeEqualTo(expected);
        }
        public void Contains_SelectorAt_With_Comparer_And_Contains_Must_ReturnTrue(int[] source, SelectorAt <int, string> selector)
        {
            // Arrange
            var value =
                System.Linq.Enumerable.Last(
                    System.Linq.Enumerable.Select(source, selector.AsFunc()));
            var wrapped = Wrap.AsValueReadOnlyCollection(source);

            // Act
            var result = ValueReadOnlyCollection
                         .Select <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
                         .Contains(value, EqualityComparer <string> .Default);

            // Assert
            _ = result.Must()
                .BeTrue();
        }
        public void Single_With_Single_Must_Return_Some(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.Single(source);

            // Act
            var result = ValueReadOnlyCollection
                         .Single <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped);

            // Assert
            _ = result.Match(
                value => value.Must().BeEqualTo(expected),
                () => throw new Exception());
        }
        public void ForEach_ActionAt_With_ValidData_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped  = Wrap.AsValueReadOnlyCollection(source);
            var result   = new List <(int, int)>();
            var expected = new List <(int, int)>();

            System.Linq.EnumerableEx.ForEach(source, (item, index) => expected.Add((item, index)));

            // Act
            ValueReadOnlyCollection
            .ForEach <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, (item, index) => result.Add((item, index)));

            // Assert
            _ = result.Must()
                .BeEnumerableOf <(int, int)>()
                .BeEqualTo(expected);
        }
        public void SkipTake_Count_With_ValidData_Must_Succeed(int[] source, int skipCount, int takeCount)
        {
            // Arrange
            var wrapped  = Wrap.AsValueReadOnlyCollection(source);
            var expected = System.Linq.Enumerable
                           .Count(System.Linq.Enumerable
                                  .Take(System.Linq.Enumerable
                                        .Skip(wrapped, skipCount), takeCount));

            // Act
            var result = ValueReadOnlyCollection
                         .SkipTake <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, skipCount, takeCount)
                         .Count();

            // Assert
            _ = result.Must()
                .BeEqualTo(expected);
        }
Beispiel #12
0
        public void ToList_With_ValidData_Collections_Must_Succeed(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueCollection(source);
            var expected =
                System.Linq.Enumerable.ToList(source);

            // Act
            var result = ValueReadOnlyCollection
                         .ToList <Wrap.ValueCollection <int>, Wrap.Enumerator <int>, int>(wrapped);

            // Assert
            _ = result.Must()
                .BeOfType <List <int> >()
                .BeEnumerableOf <int>()
                .BeEqualTo(expected);
        }
Beispiel #13
0
        public void ElementAt_With_OutOfRange_Must_Return_None(int[] source)
        {
            // Arrange
            var wrapped = Wrap.AsValueReadOnlyCollection(source);

            // Act
            var optionNegative = ValueReadOnlyCollection
                                 .ElementAt <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, -1);
            var optionTooLarge = ValueReadOnlyCollection
                                 .ElementAt <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, source.Length);

            // Assert
            _ = optionNegative.Must()
                .BeOfType <Option <int> >()
                .EvaluateTrue(option => option.IsNone);
            _ = optionTooLarge.Must()
                .BeOfType <Option <int> >()
                .EvaluateTrue(option => option.IsNone);
        }
Beispiel #14
0
        public void ToArray_SelectorAt_With_ValidData_Must_Succeed(int[] source, SelectorAt <int, string> selector)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.ToArray(
                    System.Linq.Enumerable.Select(source, selector.AsFunc()));

            // Act
            var result = ValueReadOnlyCollection
                         .Select <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
                         .ToArray();

            // Assert
            _ = result.Must()
                .BeArrayOf <string>()
                .BeEqualTo(expected);
        }
Beispiel #15
0
        public void First_Selector_With_ValidData_Must_Return_Some(int[] source, Selector <int, string> selector)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueReadOnlyCollection(source);
            var expected =
                System.Linq.Enumerable.First(
                    System.Linq.Enumerable.Select(source, selector.AsFunc()));

            // Act
            var result = ValueReadOnlyCollection
                         .Select <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
                         .First();

            // Assert
            _ = result.Match(
                value => value.Must().BeEqualTo(expected),
                () => throw new Exception());
        }
Beispiel #16
0
        public void ElementAt_With_ValidData_Must_Return_Some(int[] source)
        {
            for (var index = 0; index < source.Length; index++)
            {
                // Arrange
                var wrapped  = Wrap.AsValueReadOnlyCollection(source);
                var expected =
                    System.Linq.Enumerable.ElementAt(source, index);

                // Act
                var result = ValueReadOnlyCollection
                             .ElementAt <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int>(wrapped, index);

                // Assert
                _ = result.Match(
                    value => value.Must().BeEqualTo(expected),
                    () => throw new Exception());
            }
        }
        public void ForEach_Action_SelectorAt_With_ValidData_Must_Succeed(int[] source, SelectorAt <int, string> selector)
        {
            // Arrange
            var wrapped  = Wrap.AsValueReadOnlyCollection(source);
            var result   = new List <string>();
            var expected = new List <string>();

            System.Linq.EnumerableEx.ForEach(
                System.Linq.Enumerable.Select(source, selector.AsFunc()), item => expected.Add(item));

            // Act
            ValueReadOnlyCollection
            .Select <Wrap.ValueReadOnlyCollection <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
            .ForEach(item => result.Add(item));

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