|
#pragma warning disable CA1052 // Static holder types should be static
#pragma warning disable IDE0028 // Simplify collection initialization
#pragma warning disable IDE0090 // Use 'new(...)'
#if XUNIT_NULLABLE
#nullable enable
#else
// In case this is source-imported with global nullable enabled but no XUNIT_NULLABLE
#pragma warning disable CS8604
#endif
using System;
using System.Diagnostics.CodeAnalysis;
using System.Text.RegularExpressions;
using Xunit.Internal;
using Xunit.Sdk;
namespace Xunit
{
partial class Assert
{
/// <summary>
/// Verifies that a string contains a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
string expectedSubstring,
#if XUNIT_NULLABLE
string? actualString) =>
#else
string actualString) =>
#endif
Contains(expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
string expectedSubstring,
#if XUNIT_NULLABLE
string? actualString,
#else
string actualString,
#endif
StringComparison comparisonType)
{
GuardArgumentNotNull(nameof(expectedSubstring), expectedSubstring);
if (actualString == null || actualString.IndexOf(expectedSubstring, comparisonType) < 0)
throw ContainsException.ForSubStringNotFound(expectedSubstring, actualString);
}
/// <summary>
/// Verifies that a string contains a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
Memory<char> expectedSubstring,
Memory<char> actualString) =>
Contains((ReadOnlyMemory<char>)expectedSubstring, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
Memory<char> expectedSubstring,
ReadOnlyMemory<char> actualString) =>
Contains((ReadOnlyMemory<char>)expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
ReadOnlyMemory<char> expectedSubstring,
Memory<char> actualString) =>
Contains(expectedSubstring, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
ReadOnlyMemory<char> expectedSubstring,
ReadOnlyMemory<char> actualString) =>
Contains(expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
Memory<char> expectedSubstring,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
Contains((ReadOnlyMemory<char>)expectedSubstring, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string contains a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
Memory<char> expectedSubstring,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
Contains((ReadOnlyMemory<char>)expectedSubstring, actualString, comparisonType);
/// <summary>
/// Verifies that a string contains a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
ReadOnlyMemory<char> expectedSubstring,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
Contains(expectedSubstring, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string contains a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(
ReadOnlyMemory<char> expectedSubstring,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
GuardArgumentNotNull(nameof(expectedSubstring), expectedSubstring);
Contains(expectedSubstring.Span, actualString.Span, comparisonType);
}
/// <summary>
/// Verifies that a string contains a given string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
Span<char> expectedSubstring,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
Contains((ReadOnlySpan<char>)expectedSubstring, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string contains a given string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
Span<char> expectedSubstring,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
Contains((ReadOnlySpan<char>)expectedSubstring, actualString, comparisonType);
/// <summary>
/// Verifies that a string contains a given string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
ReadOnlySpan<char> expectedSubstring,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
Contains(expectedSubstring, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string contains a given string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
ReadOnlySpan<char> expectedSubstring,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
if (actualString.IndexOf(expectedSubstring, comparisonType) < 0)
throw ContainsException.ForSubStringNotFound(
expectedSubstring.ToString(),
actualString.ToString()
);
}
/// <summary>
/// Verifies that a string contains a given string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
Span<char> expectedSubstring,
Span<char> actualString) =>
Contains((ReadOnlySpan<char>)expectedSubstring, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
Span<char> expectedSubstring,
ReadOnlySpan<char> actualString) =>
Contains((ReadOnlySpan<char>)expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
ReadOnlySpan<char> expectedSubstring,
Span<char> actualString) =>
Contains(expectedSubstring, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string contains a given string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the string is not present inside the string</exception>
public static void Contains(
ReadOnlySpan<char> expectedSubstring,
ReadOnlySpan<char> actualString) =>
Contains(expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
string expectedSubstring,
#if XUNIT_NULLABLE
string? actualString) =>
#else
string actualString) =>
#endif
DoesNotContain(expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
string expectedSubstring,
#if XUNIT_NULLABLE
string? actualString,
#else
string actualString,
#endif
StringComparison comparisonType)
{
GuardArgumentNotNull(nameof(expectedSubstring), expectedSubstring);
if (actualString != null)
{
var idx = actualString.IndexOf(expectedSubstring, comparisonType);
if (idx >= 0)
throw DoesNotContainException.ForSubStringFound(expectedSubstring, idx, actualString);
}
}
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Memory<char> expectedSubstring,
Memory<char> actualString) =>
DoesNotContain((ReadOnlyMemory<char>)expectedSubstring, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Memory<char> expectedSubstring,
ReadOnlyMemory<char> actualString) =>
DoesNotContain((ReadOnlyMemory<char>)expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlyMemory<char> expectedSubstring,
Memory<char> actualString) =>
DoesNotContain(expectedSubstring, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlyMemory<char> expectedSubstring,
ReadOnlyMemory<char> actualString) =>
DoesNotContain(expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Memory<char> expectedSubstring,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
DoesNotContain((ReadOnlyMemory<char>)expectedSubstring, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Memory<char> expectedSubstring,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
DoesNotContain((ReadOnlyMemory<char>)expectedSubstring, actualString, comparisonType);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlyMemory<char> expectedSubstring,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
DoesNotContain(expectedSubstring, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlyMemory<char> expectedSubstring,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
GuardArgumentNotNull(nameof(expectedSubstring), expectedSubstring);
DoesNotContain(expectedSubstring.Span, actualString.Span, comparisonType);
}
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Span<char> expectedSubstring,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
DoesNotContain((ReadOnlySpan<char>)expectedSubstring, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Span<char> expectedSubstring,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
DoesNotContain((ReadOnlySpan<char>)expectedSubstring, actualString, comparisonType);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlySpan<char> expectedSubstring,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
DoesNotContain(expectedSubstring, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlySpan<char> expectedSubstring,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
var idx = actualString.IndexOf(expectedSubstring, comparisonType);
if (idx > -1)
throw DoesNotContainException.ForSubStringFound(expectedSubstring.ToString(), idx, actualString.ToString());
}
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Span<char> expectedSubstring,
Span<char> actualString) =>
DoesNotContain((ReadOnlySpan<char>)expectedSubstring, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
Span<char> expectedSubstring,
ReadOnlySpan<char> actualString) =>
DoesNotContain((ReadOnlySpan<char>)expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlySpan<char> expectedSubstring,
Span<char> actualString) =>
DoesNotContain(expectedSubstring, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
public static void DoesNotContain(
ReadOnlySpan<char> expectedSubstring,
ReadOnlySpan<char> actualString) =>
DoesNotContain(expectedSubstring, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string does not match a regular expression.
/// </summary>
/// <param name="expectedRegexPattern">The regex pattern expected not to match</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotMatchException">Thrown when the string matches the regex pattern</exception>
public static void DoesNotMatch(
[StringSyntax(StringSyntaxAttribute.Regex)]
string expectedRegexPattern,
#if XUNIT_NULLABLE
string? actualString)
#else
string actualString)
#endif
{
GuardArgumentNotNull(nameof(expectedRegexPattern), expectedRegexPattern);
if (actualString != null)
{
var match = Regex.Match(actualString, expectedRegexPattern);
if (match.Success)
{
var formattedExpected = AssertHelper.ShortenAndEncodeString(expectedRegexPattern);
var formattedActual = AssertHelper.ShortenAndEncodeString(actualString, match.Index, out var pointerIndent);
throw DoesNotMatchException.ForMatch(formattedExpected, match.Index, pointerIndent, formattedActual);
}
}
}
/// <summary>
/// Verifies that a string does not match a regular expression.
/// </summary>
/// <param name="expectedRegex">The regex expected not to match</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="DoesNotMatchException">Thrown when the string matches the regex</exception>
public static void DoesNotMatch(
Regex expectedRegex,
#if XUNIT_NULLABLE
string? actualString)
#else
string actualString)
#endif
{
GuardArgumentNotNull(nameof(expectedRegex), expectedRegex);
if (actualString != null)
{
var match = expectedRegex.Match(actualString);
if (match.Success)
{
var formattedExpected = AssertHelper.ShortenAndEncodeString(expectedRegex.ToString());
var formattedActual = AssertHelper.ShortenAndEncodeString(actualString, match.Index, out var pointerIndent);
throw DoesNotMatchException.ForMatch(formattedExpected, match.Index, pointerIndent, formattedActual);
}
}
}
/// <summary>
/// Verifies that a string is empty.
/// </summary>
/// <param name="value">The string value to be inspected</param>
/// <exception cref="ArgumentNullException">Thrown when the string is null</exception>
/// <exception cref="EmptyException">Thrown when the string is not empty</exception>
public static void Empty(string value)
{
GuardArgumentNotNull(nameof(value), value);
if (value.Length != 0)
throw EmptyException.ForNonEmptyString(value);
}
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
#if XUNIT_NULLABLE
string? expectedEndString,
string? actualString) =>
#else
string expectedEndString,
string actualString) =>
#endif
EndsWith(expectedEndString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
#if XUNIT_NULLABLE
string? expectedEndString,
string? actualString,
#else
string expectedEndString,
string actualString,
#endif
StringComparison comparisonType)
{
if (expectedEndString == null || actualString == null || !actualString.EndsWith(expectedEndString, comparisonType))
throw EndsWithException.ForStringNotFound(expectedEndString, actualString);
}
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Memory<char> expectedEndString,
Memory<char> actualString) =>
EndsWith((ReadOnlyMemory<char>)expectedEndString, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Memory<char> expectedEndString,
ReadOnlyMemory<char> actualString) =>
EndsWith((ReadOnlyMemory<char>)expectedEndString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlyMemory<char> expectedEndString,
Memory<char> actualString) =>
EndsWith(expectedEndString, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlyMemory<char> expectedEndString,
ReadOnlyMemory<char> actualString) =>
EndsWith(expectedEndString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Memory<char> expectedEndString,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
EndsWith((ReadOnlyMemory<char>)expectedEndString, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Memory<char> expectedEndString,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
EndsWith((ReadOnlyMemory<char>)expectedEndString, actualString, comparisonType);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlyMemory<char> expectedEndString,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
EndsWith(expectedEndString, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlyMemory<char> expectedEndString,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
GuardArgumentNotNull(nameof(expectedEndString), expectedEndString);
EndsWith(expectedEndString.Span, actualString.Span, comparisonType);
}
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Span<char> expectedEndString,
Span<char> actualString) =>
EndsWith((ReadOnlySpan<char>)expectedEndString, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Span<char> expectedEndString,
ReadOnlySpan<char> actualString) =>
EndsWith((ReadOnlySpan<char>)expectedEndString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlySpan<char> expectedEndString,
Span<char> actualString) =>
EndsWith(expectedEndString, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlySpan<char> expectedEndString,
ReadOnlySpan<char> actualString) =>
EndsWith(expectedEndString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Span<char> expectedEndString,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
EndsWith((ReadOnlySpan<char>)expectedEndString, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
Span<char> expectedEndString,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
EndsWith((ReadOnlySpan<char>)expectedEndString, actualString, comparisonType);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlySpan<char> expectedEndString,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
EndsWith(expectedEndString, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string ends with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedEndString">The sub-string expected to be at the end of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="EndsWithException">Thrown when the string does not end with the expected sub-string</exception>
public static void EndsWith(
ReadOnlySpan<char> expectedEndString,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
if (!actualString.EndsWith(expectedEndString, comparisonType))
throw EndsWithException.ForStringNotFound(expectedEndString.ToString(), actualString.ToString());
}
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
#if XUNIT_NULLABLE
string? expected,
string? actual) =>
#else
string expected,
string actual) =>
#endif
Equal(expected, actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks) in any non-zero quantity as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks), including zero quantities, as equivalent.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
ReadOnlySpan<char> expected,
ReadOnlySpan<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false)
{
var result = StringAssertEqualityComparer.Equivalent(expected, actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
if (!result.Equal)
throw EqualException.ForMismatchedStrings(expected.ToString(), actual.ToString(), result.MismatchIndexX ?? -1, result.MismatchIndexY ?? -1);
}
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
Memory<char> expected,
Memory<char> actual) =>
Equal((ReadOnlyMemory<char>)expected, (ReadOnlyMemory<char>)actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
Memory<char> expected,
ReadOnlyMemory<char> actual) =>
Equal((ReadOnlyMemory<char>)expected, actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
ReadOnlyMemory<char> expected,
Memory<char> actual) =>
Equal(expected, (ReadOnlyMemory<char>)actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
ReadOnlyMemory<char> expected,
ReadOnlyMemory<char> actual) =>
Equal(expected, actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks) in any non-zero quantity as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks), including zero quantities, as equivalent.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
Memory<char> expected,
Memory<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false) =>
Equal((ReadOnlyMemory<char>)expected, (ReadOnlyMemory<char>)actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks) in any non-zero quantity as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks), including zero quantities, as equivalent.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
Memory<char> expected,
ReadOnlyMemory<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false) =>
Equal((ReadOnlyMemory<char>)expected, actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks) in any non-zero quantity as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks), including zero quantities, as equivalent.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
ReadOnlyMemory<char> expected,
Memory<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false) =>
Equal(expected, (ReadOnlyMemory<char>)actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks) in any non-zero quantity as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks), including zero quantities, as equivalent.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
ReadOnlyMemory<char> expected,
ReadOnlyMemory<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false)
{
GuardArgumentNotNull(nameof(expected), expected);
Equal(
expected.Span,
actual.Span,
ignoreCase,
ignoreLineEndingDifferences,
ignoreWhiteSpaceDifferences,
ignoreAllWhiteSpace
);
}
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
Span<char> expected,
Span<char> actual) =>
Equal((ReadOnlySpan<char>)expected, (ReadOnlySpan<char>)actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
Span<char> expected,
ReadOnlySpan<char> actual) =>
Equal((ReadOnlySpan<char>)expected, actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
ReadOnlySpan<char> expected,
Span<char> actual) =>
Equal(expected, (ReadOnlySpan<char>)actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(
ReadOnlySpan<char> expected,
ReadOnlySpan<char> actual) =>
Equal(expected, actual, false, false, false, false);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats spaces and tabs (in any non-zero quantity) as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, ignores all white space differences during comparison.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
Span<char> expected,
Span<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false) =>
Equal((ReadOnlySpan<char>)expected, (ReadOnlySpan<char>)actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats spaces and tabs (in any non-zero quantity) as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, ignores all white space differences during comparison.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
Span<char> expected,
ReadOnlySpan<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false) =>
Equal((ReadOnlySpan<char>)expected, actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats spaces and tabs (in any non-zero quantity) as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, removes all whitespaces and tabs before comparing.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
ReadOnlySpan<char> expected,
Span<char> actual,
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false) =>
Equal(expected, (ReadOnlySpan<char>)actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <see langword="true"/>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <see langword="true"/>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks) in any non-zero quantity as equivalent.</param>
/// <param name="ignoreAllWhiteSpace">If set to <see langword="true"/>, treats horizontal white-space (i.e. spaces, tabs, and others; see remarks), including zero quantities, as equivalent.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
/// <remarks>
/// The <paramref name="ignoreWhiteSpaceDifferences"/> and <paramref name="ignoreAllWhiteSpace"/> flags consider
/// the following characters to be white-space:
/// <see href="https://unicode-explorer.com/c/0009">Tab</see> (\t),
/// <see href="https://unicode-explorer.com/c/0020">Space</see> (\u0020),
/// <see href="https://unicode-explorer.com/c/00A0">No-Break Space</see> (\u00A0),
/// <see href="https://unicode-explorer.com/c/1680">Ogham Space Mark</see> (\u1680),
/// <see href="https://unicode-explorer.com/c/180E">Mongolian Vowel Separator</see> (\u180E),
/// <see href="https://unicode-explorer.com/c/2000">En Quad</see> (\u2000),
/// <see href="https://unicode-explorer.com/c/2001">Em Quad</see> (\u2001),
/// <see href="https://unicode-explorer.com/c/2002">En Space</see> (\u2002),
/// <see href="https://unicode-explorer.com/c/2003">Em Space</see> (\u2003),
/// <see href="https://unicode-explorer.com/c/2004">Three-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2005">Four-Per-Em Space</see> (\u2004),
/// <see href="https://unicode-explorer.com/c/2006">Six-Per-Em Space</see> (\u2006),
/// <see href="https://unicode-explorer.com/c/2007">Figure Space</see> (\u2007),
/// <see href="https://unicode-explorer.com/c/2008">Punctuation Space</see> (\u2008),
/// <see href="https://unicode-explorer.com/c/2009">Thin Space</see> (\u2009),
/// <see href="https://unicode-explorer.com/c/200A">Hair Space</see> (\u200A),
/// <see href="https://unicode-explorer.com/c/200B">Zero Width Space</see> (\u200B),
/// <see href="https://unicode-explorer.com/c/202F">Narrow No-Break Space</see> (\u202F),
/// <see href="https://unicode-explorer.com/c/205F">Medium Mathematical Space</see> (\u205F),
/// <see href="https://unicode-explorer.com/c/3000">Ideographic Space</see> (\u3000),
/// and <see href="https://unicode-explorer.com/c/FEFF">Zero Width No-Break Space</see> (\uFEFF).
/// In particular, it does not include carriage return (\r) or line feed (\n), which are covered by
/// <paramref name="ignoreLineEndingDifferences"/>.
/// </remarks>
public static void Equal(
#if XUNIT_NULLABLE
string? expected,
string? actual,
#else
string expected,
string actual,
#endif
bool ignoreCase = false,
bool ignoreLineEndingDifferences = false,
bool ignoreWhiteSpaceDifferences = false,
bool ignoreAllWhiteSpace = false)
{
if (expected == null && actual == null)
return;
if (expected == null || actual == null)
throw EqualException.ForMismatchedStrings(expected, actual, -1, -1);
Equal(expected.AsSpan(), actual.AsSpan(), ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
}
/// <summary>
/// Verifies that a string matches a regular expression.
/// </summary>
/// <param name="expectedRegexPattern">The regex pattern expected to match</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="MatchesException">Thrown when the string does not match the regex pattern</exception>
public static void Matches(
[StringSyntax(StringSyntaxAttribute.Regex)]
string expectedRegexPattern,
#if XUNIT_NULLABLE
string? actualString)
#else
string actualString)
#endif
{
GuardArgumentNotNull(nameof(expectedRegexPattern), expectedRegexPattern);
if (actualString == null || !Regex.IsMatch(actualString, expectedRegexPattern))
throw MatchesException.ForMatchNotFound(expectedRegexPattern, actualString);
}
/// <summary>
/// Verifies that a string matches a regular expression.
/// </summary>
/// <param name="expectedRegex">The regex expected to match</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="MatchesException">Thrown when the string does not match the regex</exception>
public static void Matches(
Regex expectedRegex,
#if XUNIT_NULLABLE
string? actualString)
#else
string actualString)
#endif
{
GuardArgumentNotNull(nameof(expectedRegex), expectedRegex);
if (actualString == null || !expectedRegex.IsMatch(actualString))
throw MatchesException.ForMatchNotFound(expectedRegex.ToString(), actualString);
}
/// <summary>
/// Verifies that a string starts with a given string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="ContainsException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
#if XUNIT_NULLABLE
string? expectedStartString,
string? actualString) =>
#else
string expectedStartString,
string actualString) =>
#endif
StartsWith(expectedStartString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
#if XUNIT_NULLABLE
string? expectedStartString,
string? actualString,
#else
string expectedStartString,
string actualString,
#endif
StringComparison comparisonType)
{
if (expectedStartString == null || actualString == null || !actualString.StartsWith(expectedStartString, comparisonType))
throw StartsWithException.ForStringNotFound(expectedStartString, actualString);
}
/// <summary>
/// Verifies that a string starts with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Memory<char> expectedStartString,
Memory<char> actualString) =>
StartsWith((ReadOnlyMemory<char>)expectedStartString, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Memory<char> expectedStartString,
ReadOnlyMemory<char> actualString) =>
StartsWith((ReadOnlyMemory<char>)expectedStartString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlyMemory<char> expectedStartString,
Memory<char> actualString) =>
StartsWith(expectedStartString, (ReadOnlyMemory<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the default StringComparison.CurrentCulture comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlyMemory<char> expectedStartString,
ReadOnlyMemory<char> actualString) =>
StartsWith(expectedStartString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Memory<char> expectedStartString,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
StartsWith((ReadOnlyMemory<char>)expectedStartString, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Memory<char> expectedStartString,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
StartsWith((ReadOnlyMemory<char>)expectedStartString, actualString, comparisonType);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlyMemory<char> expectedStartString,
Memory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
StartsWith(expectedStartString, (ReadOnlyMemory<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlyMemory<char> expectedStartString,
ReadOnlyMemory<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
GuardArgumentNotNull(nameof(expectedStartString), expectedStartString);
StartsWith(expectedStartString.Span, actualString.Span, comparisonType);
}
/// <summary>
/// Verifies that a string starts with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Span<char> expectedStartString,
Span<char> actualString) =>
StartsWith((ReadOnlySpan<char>)expectedStartString, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Span<char> expectedStartString,
ReadOnlySpan<char> actualString) =>
StartsWith((ReadOnlySpan<char>)expectedStartString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlySpan<char> expectedStartString,
Span<char> actualString) =>
StartsWith(expectedStartString, (ReadOnlySpan<char>)actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlySpan<char> expectedStartString,
ReadOnlySpan<char> actualString) =>
StartsWith(expectedStartString, actualString, StringComparison.CurrentCulture);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Span<char> expectedStartString,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
StartsWith((ReadOnlySpan<char>)expectedStartString, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
Span<char> expectedStartString,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
StartsWith((ReadOnlySpan<char>)expectedStartString, actualString, comparisonType);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlySpan<char> expectedStartString,
Span<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture) =>
StartsWith(expectedStartString, (ReadOnlySpan<char>)actualString, comparisonType);
/// <summary>
/// Verifies that a string starts with a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedStartString">The sub-string expected to be at the start of the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="StartsWithException">Thrown when the string does not start with the expected sub-string</exception>
public static void StartsWith(
ReadOnlySpan<char> expectedStartString,
ReadOnlySpan<char> actualString,
StringComparison comparisonType = StringComparison.CurrentCulture)
{
if (!actualString.StartsWith(expectedStartString, comparisonType))
throw StartsWithException.ForStringNotFound(expectedStartString.ToString(), actualString.ToString());
}
}
}
|