コード例 #1
0
        public void Single_With_Multiple_Must_Return_None(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);

            // Act
            var result = wrapped.AsValueEnumerable()
                         .Single();

            // Assert
            _ = result.Must()
                .BeOfType <Option <int> >()
                .EvaluateTrue(option => option.IsNone);
        }
コード例 #2
0
        public void Single_Predicate_With_Empty_Must_Return_None(int[] source, Func <int, bool> predicate)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);

            // Act
            var result = wrapped.AsValueEnumerable()
                         .Where(predicate)
                         .Single();

            // Assert
            _ = result.Must()
                .BeOfType <Option <int> >()
                .EvaluateTrue(option => option.IsNone);
        }
コード例 #3
0
        public void Single_SelectorAt_With_Empty_Must_Return_None(int[] source, Func <int, int, string> selector)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);

            // Act
            var result = wrapped.AsValueEnumerable()
                         .Select(selector)
                         .Single();

            // Assert
            _ = result.Must()
                .BeOfType <Option <string> >()
                .EvaluateTrue(option => option.IsNone);
        }
コード例 #4
0
        public void Single_With_Single_Must_Return_Some(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);
            var expected = source
                           .Single();

            // Act
            var result = wrapped.AsValueEnumerable()
                         .Single();

            // Assert
            _ = result.Match(
                value => value.Must().BeEqualTo(expected),
                () => throw new Exception());
        }
コード例 #5
0
        public void First_Predicate_With_ValidData_Must_Return_Some(int[] source, Func <int, bool> predicate)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);
            var expected = source
                           .First(predicate);

            // Act
            var result = wrapped.AsValueEnumerable()
                         .Where(predicate)
                         .First();

            // Assert
            _ = result.Match(
                value => value.Must().BeEqualTo(expected),
                () => throw new Exception());
        }
コード例 #6
0
        public void First_SelectorAt_With_ValidData_Must_Return_Some(int[] source, Func <int, int, string> selector)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);
            var expected = source
                           .Select(selector)
                           .First();

            // Act
            var result = wrapped.AsValueEnumerable()
                         .Select(selector)
                         .First();

            // Assert
            _ = result.Match(
                value => value.Must().BeEqualTo(expected),
                () => throw new Exception());
        }
コード例 #7
0
        public void ElementAt_With_ValidData_Must_Return_Some(int[] source)
        {
            for (var index = 0; index < source.Length; index++)
            {
                // Arrange
                var wrapped = Wrap
                              .AsValueList(source);
                var expected = source
                               .ElementAt(index);

                // Act
                var result = wrapped.AsValueEnumerable()
                             .ElementAt(index);

                // Assert
                _ = result.Match(
                    value => value.Must().BeEqualTo(expected),
                    () => throw new Exception());
            }
        }
コード例 #8
0
        public void ElementAt_With_OutOfRange_Must_Return_None(int[] source)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);

            // Act
            var optionNegative = wrapped.AsValueEnumerable()
                                 .ElementAt(-1);
            var optionTooLarge = wrapped.AsValueEnumerable()
                                 .ElementAt(source.Length);

            // Assert
            _ = optionNegative.Must()
                .BeOfType <Option <int> >()
                .EvaluateTrue(option => option.IsNone);
            _ = optionTooLarge.Must()
                .BeOfType <Option <int> >()
                .EvaluateTrue(option => option.IsNone);
        }
コード例 #9
0
        public void Single_Predicate_Selector_With_Single_Must_Return_Some(int[] source, Func <int, bool> predicate, Func <int, string> selector)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);
            var expected = source
                           .Where(predicate)
                           .Select(selector)
                           .Single();

            // Act
            var result = wrapped.AsValueEnumerable()
                         .Where(predicate)
                         .Select(selector)
                         .Single();

            // Assert
            _ = result.Match(
                value => value.Must().BeEqualTo(expected),
                () => throw new Exception());
        }
コード例 #10
0
        public void ElementAt_Predicate_With_ValidData_Must_Return_Some(int[] source, Func <int, bool> predicate)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);
            var expected = source
                           .Where(predicate)
                           .ToList();

            for (var index = 0; index < expected.Count; index++)
            {
                // Act
                var result = wrapped.AsValueEnumerable()
                             .Where(predicate)
                             .ElementAt(index);

                // Assert
                _ = result.Match(
                    value => value.Must().BeEqualTo(expected[index]),
                    () => throw new Exception());
            }
        }
コード例 #11
0
        public void ElementAt_Predicate_Selector_With_OutOfRange_Must_Return_None(int[] source, Func <int, bool> predicate, Func <int, string> selector)
        {
            // Arrange
            var wrapped = Wrap
                          .AsValueList(source);

            // Act
            var optionNegative = wrapped.AsValueEnumerable()
                                 .Where(predicate)
                                 .Select(selector)
                                 .ElementAt(-1);
            var optionTooLarge = wrapped.AsValueEnumerable()
                                 .Where(predicate)
                                 .Select(selector)
                                 .ElementAt(source.Length);

            // Assert
            _ = optionNegative.Must()
                .BeOfType <Option <string> >()
                .EvaluateTrue(option => option.IsNone);
            _ = optionTooLarge.Must()
                .BeOfType <Option <string> >()
                .EvaluateTrue(option => option.IsNone);
        }