Esempio n. 1
0
        public static object[][] PassingConstraints() => new object[][]
        {
            new object[] { AtLeast.Once(), 1 },
            new object[] { AtLeast.Once(), 2 },
            new object[] { AtLeast.Twice(), 2 },
            new object[] { AtLeast.Twice(), 3 },
            new object[] { AtLeast.Thrice(), 3 },
            new object[] { AtLeast.Thrice(), 4 },
            new object[] { AtLeast.Times(4), 4 },
            new object[] { AtLeast.Times(4), 5 },

            new object[] { AtMost.Once(), 0 },
            new object[] { AtMost.Once(), 1 },
            new object[] { AtMost.Twice(), 1 },
            new object[] { AtMost.Twice(), 2 },
            new object[] { AtMost.Thrice(), 2 },
            new object[] { AtMost.Thrice(), 3 },
            new object[] { AtMost.Times(4), 3 },
            new object[] { AtMost.Times(4), 4 },

            new object[] { Exactly.Once(), 1 },
            new object[] { Exactly.Twice(), 2 },
            new object[] { Exactly.Thrice(), 3 },
            new object[] { Exactly.Times(4), 4 },

            new object[] { LessThan.Twice(), 1 },
            new object[] { LessThan.Thrice(), 2 },
            new object[] { LessThan.Times(4), 3 },

            new object[] { MoreThan.Once(), 2 },
            new object[] { MoreThan.Twice(), 3 },
            new object[] { MoreThan.Thrice(), 4 },
            new object[] { MoreThan.Times(4), 5 },
        };
                public void When_string_containment_less_than_once_is_asserted_and_actual_value_is_null_then_it_should_not_throw()
                {
                    // Arrange
                    string actual            = null;
                    string expectedSubstring = "XYZ";

                    // Act
                    Action act = () => actual.Should().Contain(expectedSubstring, LessThan.Twice());

                    // Assert
                    act.Should().NotThrow();
                }
Esempio n. 3
0
            public void When_string_containment_equivalent_of_less_than_twice_is_asserted_and_actual_value_does_not_contain_the_expected_string_it_should_throw()
            {
                // Arrange
                string actual            = "abCDEf";
                string expectedSubstring = "xyS";

                // Act
                Action act = () => actual.Should().ContainEquivalentOf(expectedSubstring, LessThan.Twice());

                // Assert
                act.Should().NotThrow();
            }