Document Using(StringComparison) and Using(CultureInfo) modifiers for string constraints (#1103)

* Initial plan

* Document Using(StringComparison) and Using(CultureInfo) modifiers for string constraints

Co-authored-by: OsirisTerje <203432+OsirisTerje@users.noreply.github.com>

* Fix CultureInfo examples to use more appropriate Turkish culture case comparison

Co-authored-by: OsirisTerje <203432+OsirisTerje@users.noreply.github.com>

* Improve CultureInfo examples to show both case-sensitive and case-insensitive usage

Co-authored-by: OsirisTerje <203432+OsirisTerje@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: OsirisTerje <203432+OsirisTerje@users.noreply.github.com> 9d92cc0

Author: SeanKilleen

articles/nunit/writing-tests/constraints/EndsWithConstraint.html

@@ -96,16 +96,33 @@ <h2 id="syntax">Syntax</h2>
 </code></pre>
 <h2 id="modifiers">Modifiers</h2>
 <pre><code class="lang-csharp">...IgnoreCase
+...Using(StringComparison comparisonType)
+...Using(CultureInfo culture)
 </code></pre>
 <h2 id="examples-of-use">Examples of Use</h2>
 <pre><code class="lang-csharp">string phrase = &quot;Make your tests fail before passing!&quot;;
 
 Assert.That(phrase, Does.EndWith(&quot;!&quot;));
 Assert.That(phrase, Does.EndWith(&quot;PASSING!&quot;).IgnoreCase);
 </code></pre>
+<h3 id="specifying-a-stringcomparison">Specifying a StringComparison</h3>
+<pre><code class="lang-csharp">Assert.That(&quot;Hello World!&quot;, Does.EndWith(&quot;WORLD!&quot;).Using(StringComparison.OrdinalIgnoreCase));
+Assert.That(&quot;Hello World!&quot;, Does.EndWith(&quot;World!&quot;).Using(StringComparison.Ordinal));
+</code></pre>
+<h3 id="specifying-a-cultureinfo">Specifying a CultureInfo</h3>
+<p>The <code>Using(CultureInfo)</code> modifier allows for culture-specific string comparisons.
+It can be combined with <code>.IgnoreCase</code> for case-insensitive culture-aware comparisons:</p>
+<pre><code class="lang-csharp">// Using Turkish culture where 'i' and 'I' have special casing rules
+Assert.That(&quot;text TITLE&quot;, Does.EndWith(&quot;title&quot;).IgnoreCase.Using(new CultureInfo(&quot;tr-TR&quot;)));
+
+// Culture-specific comparison without case-insensitivity
+Assert.That(&quot;Main Straße&quot;, Does.EndWith(&quot;Straße&quot;).Using(new CultureInfo(&quot;de-DE&quot;)));
+</code></pre>
 <h2 id="notes">Notes</h2>
 <ol>
 <li><strong>EndsWith</strong> may appear only in the body of a constraint expression or when the inherited syntax is used.</li>
+<li>Only one <code>Using</code> modifier may be specified. Attempting to use multiple <code>Using</code> modifiers
+will throw an <code>InvalidOperationException</code>.</li>
 </ol>
 
 </article>

articles/nunit/writing-tests/constraints/StartsWithConstraint.html

@@ -96,17 +96,34 @@ <h2 id="syntax">Syntax</h2>
 </code></pre>
 <h2 id="modifiers">Modifiers</h2>
 <pre><code class="lang-csharp">...IgnoreCase
+...Using(StringComparison comparisonType)
+...Using(CultureInfo culture)
 </code></pre>
 <h2 id="examples-of-use">Examples of Use</h2>
 <pre><code class="lang-csharp">string phrase = &quot;Make your tests fail before passing!&quot;;
 
 Assert.That(phrase, Does.StartWith(&quot;Make&quot;));
 Assert.That(phrase, Does.Not.StartWith(&quot;Break&quot;));
 </code></pre>
+<h3 id="specifying-a-stringcomparison">Specifying a StringComparison</h3>
+<pre><code class="lang-csharp">Assert.That(&quot;Hello World!&quot;, Does.StartWith(&quot;HELLO&quot;).Using(StringComparison.OrdinalIgnoreCase));
+Assert.That(&quot;Hello World!&quot;, Does.StartWith(&quot;Hello&quot;).Using(StringComparison.Ordinal));
+</code></pre>
+<h3 id="specifying-a-cultureinfo">Specifying a CultureInfo</h3>
+<p>The <code>Using(CultureInfo)</code> modifier allows for culture-specific string comparisons.
+It can be combined with <code>.IgnoreCase</code> for case-insensitive culture-aware comparisons:</p>
+<pre><code class="lang-csharp">// Using Turkish culture where 'i' and 'I' have special casing rules
+Assert.That(&quot;TITLE text&quot;, Does.StartWith(&quot;title&quot;).IgnoreCase.Using(new CultureInfo(&quot;tr-TR&quot;)));
+
+// Culture-specific comparison without case-insensitivity
+Assert.That(&quot;Straße Street&quot;, Does.StartWith(&quot;Straße&quot;).Using(new CultureInfo(&quot;de-DE&quot;)));
+</code></pre>
 <h2 id="notes">Notes</h2>
 <ol>
 <li><strong>StartsWith</strong> may appear only in the body of a constraint
 expression or when the inherited syntax is used.</li>
+<li>Only one <code>Using</code> modifier may be specified. Attempting to use multiple <code>Using</code> modifiers
+will throw an <code>InvalidOperationException</code>.</li>
 </ol>
 
 </article>

articles/nunit/writing-tests/constraints/SubstringConstraint.html

@@ -95,6 +95,8 @@ <h2 id="syntax">Syntax</h2>
 </code></pre>
 <h2 id="modifiers">Modifiers</h2>
 <pre><code class="lang-csharp">...IgnoreCase
+...Using(StringComparison comparisonType)
+...Using(CultureInfo culture)
 </code></pre>
 <h2 id="examples-of-use">Examples of Use</h2>
 <pre><code class="lang-csharp" name="StringConstraintExamples">[Test]
@@ -105,7 +107,25 @@ <h2 id="examples-of-use">Examples of Use</h2>
     Assert.That(&quot;Hello World!&quot;, Does.Contain(&quot;lo Wor&quot;));
     Assert.That(&quot;Hello World!&quot;, Does.Match(&quot;H.*!&quot;));
 }
+</code></pre><h3 id="specifying-a-stringcomparison">Specifying a StringComparison</h3>
+<pre><code class="lang-csharp">Assert.That(&quot;Hello World!&quot;, Does.Contain(&quot;WORLD&quot;).Using(StringComparison.OrdinalIgnoreCase));
+Assert.That(&quot;Hello World!&quot;, Does.Contain(&quot;World&quot;).Using(StringComparison.Ordinal));
 </code></pre>
+<h3 id="specifying-a-cultureinfo">Specifying a CultureInfo</h3>
+<p>The <code>Using(CultureInfo)</code> modifier allows for culture-specific string comparisons.
+It can be combined with <code>.IgnoreCase</code> for case-insensitive culture-aware comparisons:</p>
+<pre><code class="lang-csharp">// Using Turkish culture where 'i' and 'I' have special casing rules
+Assert.That(&quot;Hello TITLE World&quot;, Does.Contain(&quot;title&quot;).IgnoreCase.Using(new CultureInfo(&quot;tr-TR&quot;)));
+
+// Culture-specific comparison without case-insensitivity
+Assert.That(&quot;Straße Street&quot;, Does.Contain(&quot;Straße&quot;).Using(new CultureInfo(&quot;de-DE&quot;)));
+</code></pre>
+<h2 id="notes">Notes</h2>
+<ol>
+<li>Only one <code>Using</code> modifier may be specified. Attempting to use multiple <code>Using</code> modifiers
+will throw an <code>InvalidOperationException</code>.</li>
+</ol>
+
 </article>
           </div>
 

index.json

@@ -3342,7 +3342,7 @@
   "articles/nunit/writing-tests/constraints/EndsWithConstraint.html": {
     "href": "articles/nunit/writing-tests/constraints/EndsWithConstraint.html",
     "title": "EndsWith Constraint | NUnit Docs",
-    "summary": "EndsWith Constraint EndsWithConstraint tests for an ending string. Constructor EndsWithConstraint(string expected) Syntax Does.EndWith(string expected) EndsWith(string expected) Modifiers ...IgnoreCase Examples of Use string phrase = \"Make your tests fail before passing!\"; Assert.That(phrase, Does.EndWith(\"!\")); Assert.That(phrase, Does.EndWith(\"PASSING!\").IgnoreCase); Notes EndsWith may appear only in the body of a constraint expression or when the inherited syntax is used."
+    "summary": "EndsWith Constraint EndsWithConstraint tests for an ending string. Constructor EndsWithConstraint(string expected) Syntax Does.EndWith(string expected) EndsWith(string expected) Modifiers ...IgnoreCase ...Using(StringComparison comparisonType) ...Using(CultureInfo culture) Examples of Use string phrase = \"Make your tests fail before passing!\"; Assert.That(phrase, Does.EndWith(\"!\")); Assert.That(phrase, Does.EndWith(\"PASSING!\").IgnoreCase); Specifying a StringComparison Assert.That(\"Hello World!\", Does.EndWith(\"WORLD!\").Using(StringComparison.OrdinalIgnoreCase)); Assert.That(\"Hello World!\", Does.EndWith(\"World!\").Using(StringComparison.Ordinal)); Specifying a CultureInfo The Using(CultureInfo) modifier allows for culture-specific string comparisons. It can be combined with .IgnoreCase for case-insensitive culture-aware comparisons: // Using Turkish culture where 'i' and 'I' have special casing rules Assert.That(\"text TITLE\", Does.EndWith(\"title\").IgnoreCase.Using(new CultureInfo(\"tr-TR\"))); // Culture-specific comparison without case-insensitivity Assert.That(\"Main Straße\", Does.EndWith(\"Straße\").Using(new CultureInfo(\"de-DE\"))); Notes EndsWith may appear only in the body of a constraint expression or when the inherited syntax is used. Only one Using modifier may be specified. Attempting to use multiple Using modifiers will throw an InvalidOperationException."
   },
   "articles/nunit/writing-tests/constraints/EqualConstraint.html": {
     "href": "articles/nunit/writing-tests/constraints/EqualConstraint.html",
@@ -3467,7 +3467,7 @@
   "articles/nunit/writing-tests/constraints/StartsWithConstraint.html": {
     "href": "articles/nunit/writing-tests/constraints/StartsWithConstraint.html",
     "title": "StartsWith Constraint | NUnit Docs",
-    "summary": "StartsWith Constraint StartsWithConstraint tests for an initial string. Constructor StartsWithConstraint(string expected) Syntax Does.StartWith(string expected) StartsWith(string expected) Modifiers ...IgnoreCase Examples of Use string phrase = \"Make your tests fail before passing!\"; Assert.That(phrase, Does.StartWith(\"Make\")); Assert.That(phrase, Does.Not.StartWith(\"Break\")); Notes StartsWith may appear only in the body of a constraint expression or when the inherited syntax is used."
+    "summary": "StartsWith Constraint StartsWithConstraint tests for an initial string. Constructor StartsWithConstraint(string expected) Syntax Does.StartWith(string expected) StartsWith(string expected) Modifiers ...IgnoreCase ...Using(StringComparison comparisonType) ...Using(CultureInfo culture) Examples of Use string phrase = \"Make your tests fail before passing!\"; Assert.That(phrase, Does.StartWith(\"Make\")); Assert.That(phrase, Does.Not.StartWith(\"Break\")); Specifying a StringComparison Assert.That(\"Hello World!\", Does.StartWith(\"HELLO\").Using(StringComparison.OrdinalIgnoreCase)); Assert.That(\"Hello World!\", Does.StartWith(\"Hello\").Using(StringComparison.Ordinal)); Specifying a CultureInfo The Using(CultureInfo) modifier allows for culture-specific string comparisons. It can be combined with .IgnoreCase for case-insensitive culture-aware comparisons: // Using Turkish culture where 'i' and 'I' have special casing rules Assert.That(\"TITLE text\", Does.StartWith(\"title\").IgnoreCase.Using(new CultureInfo(\"tr-TR\"))); // Culture-specific comparison without case-insensitivity Assert.That(\"Straße Street\", Does.StartWith(\"Straße\").Using(new CultureInfo(\"de-DE\"))); Notes StartsWith may appear only in the body of a constraint expression or when the inherited syntax is used. Only one Using modifier may be specified. Attempting to use multiple Using modifiers will throw an InvalidOperationException."
   },
   "articles/nunit/writing-tests/constraints/SubPathConstraint.html": {
     "href": "articles/nunit/writing-tests/constraints/SubPathConstraint.html",
@@ -3477,7 +3477,7 @@
   "articles/nunit/writing-tests/constraints/SubstringConstraint.html": {
     "href": "articles/nunit/writing-tests/constraints/SubstringConstraint.html",
     "title": "Substring Constraint | NUnit Docs",
-    "summary": "Substring Constraint SubstringConstraint tests for a substring. Constructor SubstringConstraint(string expected) Syntax Does.Contain(string expected) Modifiers ...IgnoreCase Examples of Use [Test] public void StringConstraint_Examples() { Assert.That(\"Hello World!\", Does.StartWith(\"Hello\")); Assert.That(\"Hello World!\", Does.EndWith(\"World!\")); Assert.That(\"Hello World!\", Does.Contain(\"lo Wor\")); Assert.That(\"Hello World!\", Does.Match(\"H.*!\")); }"
+    "summary": "Substring Constraint SubstringConstraint tests for a substring. Constructor SubstringConstraint(string expected) Syntax Does.Contain(string expected) Modifiers ...IgnoreCase ...Using(StringComparison comparisonType) ...Using(CultureInfo culture) Examples of Use [Test] public void StringConstraint_Examples() { Assert.That(\"Hello World!\", Does.StartWith(\"Hello\")); Assert.That(\"Hello World!\", Does.EndWith(\"World!\")); Assert.That(\"Hello World!\", Does.Contain(\"lo Wor\")); Assert.That(\"Hello World!\", Does.Match(\"H.*!\")); } Specifying a StringComparison Assert.That(\"Hello World!\", Does.Contain(\"WORLD\").Using(StringComparison.OrdinalIgnoreCase)); Assert.That(\"Hello World!\", Does.Contain(\"World\").Using(StringComparison.Ordinal)); Specifying a CultureInfo The Using(CultureInfo) modifier allows for culture-specific string comparisons. It can be combined with .IgnoreCase for case-insensitive culture-aware comparisons: // Using Turkish culture where 'i' and 'I' have special casing rules Assert.That(\"Hello TITLE World\", Does.Contain(\"title\").IgnoreCase.Using(new CultureInfo(\"tr-TR\"))); // Culture-specific comparison without case-insensitivity Assert.That(\"Straße Street\", Does.Contain(\"Straße\").Using(new CultureInfo(\"de-DE\"))); Notes Only one Using modifier may be specified. Attempting to use multiple Using modifiers will throw an InvalidOperationException."
   },
   "articles/nunit/writing-tests/constraints/ThrowsConstraint.html": {
     "href": "articles/nunit/writing-tests/constraints/ThrowsConstraint.html",