Add more specific variants of contain (continued)

Src/FluentAssertions/AtLeast.cs

@@ -0,0 +1,22 @@
+namespace FluentAssertions
+{
+    public static class AtLeast
+    {
+        public static OccurrenceConstraint Once() => new AtLeastTimesConstraint(1);
+
+        public static OccurrenceConstraint Twice() => new AtLeastTimesConstraint(2);
+
+        public static OccurrenceConstraint Thrice() => new AtLeastTimesConstraint(3);
+
+        public static OccurrenceConstraint Times(int expected) => new AtLeastTimesConstraint(expected);
+
+        private sealed class AtLeastTimesConstraint : OccurrenceConstraint
+        {
+            internal AtLeastTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+            internal override string Mode => "at least";
+
+            internal override bool Assert(int actual) => actual >= ExpectedCount;
+        }
+    }
+}

Src/FluentAssertions/AtMost.cs

@@ -0,0 +1,22 @@
+namespace FluentAssertions
+{
+    public static class AtMost
+    {
+        public static OccurrenceConstraint Once() => new AtMostTimesConstraint(1);
+
+        public static OccurrenceConstraint Twice() => new AtMostTimesConstraint(2);
+
+        public static OccurrenceConstraint Thrice() => new AtMostTimesConstraint(3);
+
+        public static OccurrenceConstraint Times(int expected) => new AtMostTimesConstraint(expected);
+
+        private sealed class AtMostTimesConstraint : OccurrenceConstraint
+        {
+            internal AtMostTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+            internal override string Mode => "at most";
+
+            internal override bool Assert(int actual) => actual <= ExpectedCount;
+        }
+    }
+}

Src/FluentAssertions/Common/IntegerExtensions.cs

@@ -0,0 +1,7 @@
+namespace FluentAssertions.Common
+{
+    internal static class IntegerExtensions
+    {
+        public static string Times(this int count) => count == 1 ? "1 time" : $"{count} times";
+    }
+}

Src/FluentAssertions/Common/StringExtensions.cs

@@ -97,5 +97,28 @@ public static string RemoveNewLines(this string @this)
         {
             return @this.Replace("\n", "").Replace("\r", "").Replace("\\r\\n", "");
         }
+
+        /// <summary>
+        /// Counts the number of times a substring appears within a string by using the specified <see cref="StringComparison"/>.
+        /// </summary>
+        /// <param name="substring">The substring to search for.</param>
+        /// <param name="comparisonType">The <see cref="StringComparison"/> option to use for comparison.</param>
+        /// <returns></returns>
+        public static int CountSubstring(this string @this, string substring, StringComparison comparisonType)
+        {
+            string actual = @this ?? "";
+            string search = substring ?? "";
+
+            int count = 0;
+            int index = 0;
+
+            while ((index = actual.IndexOf(search, index, comparisonType)) >= 0)
+            {
+                index += search.Length;
+                count++;
+            }
+
+            return count;
+        }
     }
 }

Src/FluentAssertions/Exactly.cs

@@ -0,0 +1,22 @@
+namespace FluentAssertions
+{
+    public static class Exactly
+    {
+        public static OccurrenceConstraint Once() => new ExactlyTimesConstraint(1);
+
+        public static OccurrenceConstraint Twice() => new ExactlyTimesConstraint(2);
+
+        public static OccurrenceConstraint Thrice() => new ExactlyTimesConstraint(3);
+
+        public static OccurrenceConstraint Times(int expected) => new ExactlyTimesConstraint(expected);
+
+        private sealed class ExactlyTimesConstraint : OccurrenceConstraint
+        {
+            internal ExactlyTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+            internal override string Mode => "exactly";
+
+            internal override bool Assert(int actual) => actual == ExpectedCount;
+        }
+    }
+}

Src/FluentAssertions/LessThan.cs

@@ -0,0 +1,20 @@
+namespace FluentAssertions
+{
+    public static class LessThan
+    {
+        public static OccurrenceConstraint Twice() => new LessThanTimesConstraint(2);
+
+        public static OccurrenceConstraint Thrice() => new LessThanTimesConstraint(3);
+
+        public static OccurrenceConstraint Times(int expected) => new LessThanTimesConstraint(expected);
+
+        private sealed class LessThanTimesConstraint : OccurrenceConstraint
+        {
+            internal LessThanTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+            internal override string Mode => "less than";
+
+            internal override bool Assert(int actual) => actual < ExpectedCount;
+        }
+    }
+}

Src/FluentAssertions/MoreThan.cs

@@ -0,0 +1,22 @@
+namespace FluentAssertions
+{
+    public static class MoreThan
+    {
+        public static OccurrenceConstraint Once() => new MoreThanTimesConstraint(1);
+
+        public static OccurrenceConstraint Twice() => new MoreThanTimesConstraint(2);
+
+        public static OccurrenceConstraint Thrice() => new MoreThanTimesConstraint(3);
+
+        public static OccurrenceConstraint Times(int expected) => new MoreThanTimesConstraint(expected);
+
+        private sealed class MoreThanTimesConstraint : OccurrenceConstraint
+        {
+            internal MoreThanTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+            internal override string Mode => "more than";
+
+            internal override bool Assert(int actual) => actual > ExpectedCount;
+        }
+    }
+}

Src/FluentAssertions/OccurrenceConstraint.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace FluentAssertions
+{
+    public abstract class OccurrenceConstraint
+    {
+        protected OccurrenceConstraint(int expectedCount)
+        {
+            if (expectedCount < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(expectedCount), "Expected count cannot be negative.");
+            }
+
+            ExpectedCount = expectedCount;
+        }
+
+        internal int ExpectedCount { get; private set; }
+
+        internal abstract string Mode { get; }
+
+        internal abstract bool Assert(int actual);
+    }
+}

Src/FluentAssertions/Primitives/StringAssertions.cs

@@ -636,6 +636,46 @@ public AndConstraint<StringAssertions> Contain(string expected, string because =
             return new AndConstraint<StringAssertions>(this);
         }
 
+        /// <summary>
+        /// Asserts that a string contains another (fragment of a) string a set amount of times.
+        /// </summary>
+        /// <param name="expected">
+        /// The (fragment of a) string that the current string should contain.
+        /// </param>
+        /// <param name="occurrenceConstraint">
+        /// A constraint specifying the amount of times a substring should be present within the test subject.
+        /// It can be created by invoking static methods Once, Twice, Thrice, or Times(int)
+        /// on the classes <see cref="Exactly"/>, <see cref="AtLeast"/>, <see cref="MoreThan"/>, <see cref="AtMost"/>, and <see cref="LessThan"/>.
+        /// For example, <see cref="Exactly.Times(int)"/> or <see cref="LessThan.Twice()"/>.
+        /// </param>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <see cref="because" />.
+        /// </param>
+        public AndConstraint<StringAssertions> Contain(string expected, OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs)
+        {
+            Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot assert string containment against <null>.");
+
+            if (expected.Length == 0)
+            {
+                throw new ArgumentException("Cannot assert string containment against an empty string.", nameof(expected));
+            }
+
+            int actual = Subject.CountSubstring(expected, StringComparison.Ordinal);
+
+            Execute.Assertion
+                .ForCondition(occurrenceConstraint.Assert(actual))
+                .BecauseOf(because, becauseArgs)
+                .FailWith(
+                    $"Expected {{context:string}} {{0}} to contain {{1}} {occurrenceConstraint.Mode} {occurrenceConstraint.ExpectedCount.Times()}{{reason}}, but found it {actual.Times()}.",
+                    Subject, expected);
+
+            return new AndConstraint<StringAssertions>(this);
+        }
+
         /// <summary>
         /// Asserts that a string contains the specified <paramref name="expected"/>,
         /// including any leading or trailing whitespace, with the exception of the casing.
@@ -660,7 +700,48 @@ public AndConstraint<StringAssertions> ContainEquivalentOf(string expected, stri
             Execute.Assertion
                 .ForCondition(Contains(Subject, expected, StringComparison.CurrentCultureIgnoreCase))
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context:string} to contain equivalent of {0}{reason} but found {1}.", expected, Subject);
+                .FailWith("Expected {context:string} {0} to contain the equivalent of {1}{reason}.", Subject, expected);
+
+            return new AndConstraint<StringAssertions>(this);
+        }
+
+        /// <summary>
+        /// Asserts that a string contains the specified <paramref name="expected"/> a set amount of times,
+        /// including any leading or trailing whitespace, with the exception of the casing.
+        /// </summary>
+        /// <param name="expected">
+        /// The (fragment of a) string that the current string should contain.
+        /// </param>
+        /// <param name="occurrenceConstraint">
+        /// A constraint specifying the amount of times a substring should be present within the test subject.
+        /// It can be created by invoking static methods Once, Twice, Thrice, or Times(int)
+        /// on the classes <see cref="Exactly"/>, <see cref="AtLeast"/>, <see cref="MoreThan"/>, <see cref="AtMost"/>, and <see cref="LessThan"/>.
+        /// For example, <see cref="Exactly.Times(int)"/> or <see cref="LessThan.Twice()"/>.
+        /// </param>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <see cref="because" />.
+        /// </param>
+        public AndConstraint<StringAssertions> ContainEquivalentOf(string expected, OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs)
+        {
+            Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot assert string containment against <null>.");
+
+            if (expected.Length == 0)
+            {
+                throw new ArgumentException("Cannot assert string containment against an empty string.", nameof(expected));
+            }
+
+            int actual = Subject.CountSubstring(expected, StringComparison.OrdinalIgnoreCase);
+
+            Execute.Assertion
+                .ForCondition(occurrenceConstraint.Assert(actual))
+                .BecauseOf(because, becauseArgs)
+                .FailWith(
+                    $"Expected {{context:string}} {{0}} to contain equivalent of {{1}} {occurrenceConstraint.Mode} {occurrenceConstraint.ExpectedCount.Times()}{{reason}}, but found it {actual.Times()}.",
+                    Subject, expected);
 
             return new AndConstraint<StringAssertions>(this);
         }