Add more specific variants of contain (continued)

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/Primitives/StringAssertions.cs

@@ -631,7 +631,40 @@ public AndConstraint<StringAssertions> Contain(string expected, string because =
             Execute.Assertion
                 .ForCondition(Contains(Subject, expected, StringComparison.Ordinal))
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context:string} {0} to contain {1}{reason}.", Subject, expected);
+                .FailWith("Expected {context:string} {0} to contain {1}{reason}, but not found.", Subject, expected);
+
+            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="timesConstraint">
+        /// 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, TimesConstraint timesConstraint, 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));
+            }
+
+            timesConstraint.AssertContain(Subject, expected, because, becauseArgs);
 
             return new AndConstraint<StringAssertions>(this);
         }
@@ -660,7 +693,40 @@ 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 equivalent of {1}{reason}, but not found.", Subject, expected);
+
+            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="timesConstraint">
+        /// 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, TimesConstraint timesConstraint, 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));
+            }
+
+            timesConstraint.AssertContainEquivalentOf(Subject, expected, because, becauseArgs);
 
             return new AndConstraint<StringAssertions>(this);
         }

Src/FluentAssertions/Primitives/TimesConstraint.cs

@@ -0,0 +1,169 @@
+using System;
+using FluentAssertions.Common;
+using FluentAssertions.Execution;
+
+namespace FluentAssertions.Primitives
+{
+    public abstract class TimesConstraint
+    {
+        private int? actualCount;
+
+        protected readonly int expectedCount;
+
+        public TimesConstraint(int expectedCount)
+        {
+            this.expectedCount = expectedCount;
+        }
+
+        protected int ActualCount
+        {
+            get
+            {
+                if (!actualCount.HasValue)
+                {
+                    actualCount = Subject.CountSubstring(Expected, StringComparison);
+                }
+
+                return actualCount.Value;
+            }
+        }
+
+        protected abstract string Mode { get; }
+
+        protected abstract bool IsMatch { get; }
+
+        private string Expected { get; set; }
+
+        private string Subject { get; set; }
+
+        private StringComparison StringComparison { get; set; }
+
+        private static string Times(int count) => count == 1 ? "1 time" : $"{count} times";
+
+        internal void AssertContain(string subject, string expected, string because, params object[] becauseArgs)
+        {
+            Subject = subject;
+            Expected = expected;
+            StringComparison = StringComparison.Ordinal;
+
+            Execute.Assertion
+                .ForCondition(IsMatch)
+                .BecauseOf(because, becauseArgs)
+                .FailWith(
+                    $"Expected {{context:string}} {{0}} to contain {{1}} {Mode} {Times(expectedCount)}{{reason}}, but found {Times(ActualCount)}.",
+                    Subject, expected);
+        }
+
+        internal void AssertContainEquivalentOf(string subject, string expected, string because, params object[] becauseArgs)
+        {
+            Subject = subject;
+            Expected = expected;
+            StringComparison = StringComparison.CurrentCultureIgnoreCase;
+
+            Execute.Assertion
+                .ForCondition(IsMatch)
+                .BecauseOf(because, becauseArgs)
+                .FailWith(
+                    $"Expected {{context:string}} {{0}} to contain equivalent of {{1}} {Mode} {Times(expectedCount)}{{reason}}, but found {Times(ActualCount)}.",
+                    Subject, expected);
+        }
+    }
+
+    internal sealed class AtLeastTimesConstraint : TimesConstraint
+    {
+        internal AtLeastTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+        protected override string Mode => "at least";
+
+        protected override bool IsMatch => ActualCount >= expectedCount;
+    }
+
+    internal sealed class AtMostTimesConstraint : TimesConstraint
+    {
+        internal AtMostTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+        protected override string Mode => "at most";
+
+        protected override bool IsMatch => ActualCount <= expectedCount;
+    }
+
+    internal sealed class MoreThanTimesConstraint : TimesConstraint
+    {
+        internal MoreThanTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+        protected override string Mode => "more than";
+
+        protected override bool IsMatch => ActualCount > expectedCount;
+    }
+
+    internal sealed class LessThanTimesConstraint : TimesConstraint
+    {
+        internal LessThanTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+        protected override string Mode => "less than";
+
+        protected override bool IsMatch => ActualCount < expectedCount;
+    }
+
+    internal sealed class ExactlyTimesConstraint : TimesConstraint
+    {
+        internal ExactlyTimesConstraint(int expectedCount) : base(expectedCount) { }
+
+        protected override string Mode => "exactly";
+
+        protected override bool IsMatch => ActualCount == expectedCount;
+    }
+
+    public static class AtLeast
+    {
+        public static TimesConstraint Once() => new AtLeastTimesConstraint(1);
+
+        public static TimesConstraint Twice() => new AtLeastTimesConstraint(2);
+
+        public static TimesConstraint Thrice() => new AtLeastTimesConstraint(3);
+
+        public static TimesConstraint Times(int expected) => new AtLeastTimesConstraint(expected);
+    }
+
+    public static class AtMost
+    {
+        public static TimesConstraint Once() => new AtMostTimesConstraint(1);
+
+        public static TimesConstraint Twice() => new AtMostTimesConstraint(2);
+
+        public static TimesConstraint Thrice() => new AtMostTimesConstraint(3);
+
+        public static TimesConstraint Times(int expected) => new AtMostTimesConstraint(expected);
+    }
+
+    public static class MoreThan
+    {
+        public static TimesConstraint Once() => new MoreThanTimesConstraint(1);
+
+        public static TimesConstraint Twice() => new MoreThanTimesConstraint(2);
+
+        public static TimesConstraint Thrice() => new MoreThanTimesConstraint(3);
+
+        public static TimesConstraint Times(int expected) => new MoreThanTimesConstraint(expected);
+    }
+
+    public static class LessThan
+    {
+        public static TimesConstraint Twice() => new LessThanTimesConstraint(2);
+
+        public static TimesConstraint Thrice() => new LessThanTimesConstraint(3);
+
+        public static TimesConstraint Times(int expected) => new LessThanTimesConstraint(expected);
+    }
+
+    public static class Exactly
+    {
+        public static TimesConstraint Once() => new ExactlyTimesConstraint(1);
+
+        public static TimesConstraint Twice() => new ExactlyTimesConstraint(2);
+
+        public static TimesConstraint Thrice() => new ExactlyTimesConstraint(3);
+
+        public static TimesConstraint Times(int expected) => new ExactlyTimesConstraint(expected);
+    }
+}