/// <summary>
/// Verifies that a value is false.
/// </summary>
/// <param name="condition">The value to check.</param>
/// <param name="message">The failure message.</param>
/// <param name="parameters">The message parameters.</param>
public static void IsFalse(bool condition, string message = null, object[] parameters = null)
{
if (condition)
{
Assert.HandleFail("Assert.IsFalse", message, parameters);
}
}
private static void StringPreAssert(string target, string actual, string methodName)
{
// string values should not be undefined
if (target == window.undefined)
{
Assert.HandleFail(methodName, "The target value cannot be undefined.", null);
}
if (actual == window.undefined)
{
Assert.HandleFail(methodName, "The actual value cannot be undefined.", null);
}
// string values should have a toLowerCase method
if (target != null)
{
if (!target["toLowerCase"])
{
Assert.HandleFail(methodName, "The target value must be either null or a valid string object.", null);
}
}
if (actual != null)
{
if (!actual["toLowerCase"])
{
Assert.HandleFail(methodName, "The actual value must be either null or a valid string object.", null);
}
}
}
/// <summary>
/// Verifies that a value is null or undefined.
/// </summary>
/// <param name="value">The value to check.</param>
/// <param name="message">The failure message.</param>
/// <param name="parameters">The message parameters.</param>
public static void IsNullOrUndefined(object value, string message = null, object[] parameters = null)
{
if (value != null && value != window.undefined)
{
Assert.HandleFail("Assert.IsNullOrUndefined", message, parameters);
}
}
/// <summary>
/// Verifies that a value is not null.
/// </summary>
/// <param name="value">The value to check.</param>
/// <param name="message">The failure message.</param>
/// <param name="parameters">The message parameters.</param>
public static void IsNotNull(object value, string message = null, object[] parameters = null)
{
if (value == null)
{
Assert.HandleFail("Assert.IsNotNull", message, parameters);
}
}
/// <summary>
/// Verifies that two values not equal.
/// </summary>
/// <param name="notExpected">The unexpected value.</param>
/// <param name="actual">The actual value.</param>
/// <param name="message">The failure message.</param>
/// <param name="parameters">The message parameters.</param>
public static void AreNotEqual(object notExpected, object actual, string message = null, object[] parameters = null)
{
if (notExpected == actual)
{
Assert.HandleFail("Assert.AreNotEqual", message, parameters);
}
}
public static void IsNotNull(object value, string message, params object[] parameters)
{
if (value != null)
{
return;
}
Assert.HandleFail("Assert.IsNotNull", message, parameters);
}
public static void AreNotEqual(double notExpected, double actual, double delta, string message, params object[] parameters)
{
if (Math.Abs(notExpected - actual) > delta)
{
return;
}
Assert.HandleFail("Assert.AreNotEqual", (string)FrameworkMessages.AreNotEqualDeltaFailMsg(message == null ? (object)string.Empty : (object)Assert.ReplaceNulls((object)message), (object)notExpected.ToString((IFormatProvider)CultureInfo.CurrentCulture.NumberFormat), (object)actual.ToString((IFormatProvider)CultureInfo.CurrentCulture.NumberFormat), (object)delta.ToString((IFormatProvider)CultureInfo.CurrentCulture.NumberFormat)), parameters);
}
public static void IsFalse(bool condition, string message, params object[] parameters)
{
if (!condition)
{
return;
}
Assert.HandleFail("Assert.IsFalse", message, parameters);
}
public static void AreNotEqual <T>(T notExpected, T actual, string message, params object[] parameters)
{
if (!object.Equals((object)notExpected, (object)actual))
{
return;
}
Assert.HandleFail("Assert.AreNotEqual", (string)FrameworkMessages.AreNotEqualFailMsg(message == null ? (object)string.Empty : (object)Assert.ReplaceNulls((object)message), (object)Assert.ReplaceNulls((object)notExpected), (object)Assert.ReplaceNulls((object)actual)), parameters);
}
internal static void CheckParameterNotNull(object param, string assertionName, string parameterName, string message, params object[] parameters)
{
if (param != null)
{
return;
}
Assert.HandleFail(assertionName, (string)FrameworkMessages.NullParameterToAssert((object)parameterName, (object)message), parameters);
}
public static void AreNotSame(object notExpected, object actual, string message, params object[] parameters)
{
if (!object.ReferenceEquals(notExpected, actual))
{
return;
}
Assert.HandleFail("Assert.AreNotSame", message, parameters);
}
public static void AreEqual <T>(T expected, T actual, string message, params object[] parameters)
{
if (object.Equals((object)expected, (object)actual))
{
return;
}
Assert.HandleFail("Assert.AreEqual", (object)actual == null || (object)expected == null || actual.GetType().Equals(expected.GetType()) ? (string)FrameworkMessages.AreEqualFailMsg(message == null ? (object)string.Empty : (object)Assert.ReplaceNulls((object)message), (object)Assert.ReplaceNulls((object)expected), (object)Assert.ReplaceNulls((object)actual)) : (string)FrameworkMessages.AreEqualDifferentTypesFailMsg(message == null ? (object)string.Empty : (object)Assert.ReplaceNulls((object)message), (object)Assert.ReplaceNulls((object)expected), (object)expected.GetType().FullName, (object)Assert.ReplaceNulls((object)actual), (object)actual.GetType().FullName), parameters);
}
/// <summary>
/// Verifies that two numbers are not equal.
/// </summary>
/// <param name="notExpected">The unexpected value.</param>
/// <param name="actual">The actual value.</param>
/// <param name="delta"></param>
/// <param name="message">The failure message.</param>
/// <param name="parameters">The message parameters.</param>
public static void AreNotEqualNumbers(INumber notExpected, INumber actual, INumber delta, string message = null, object[] parameters = null)
{
NumericPreAssert(notExpected, actual, "Assert.AreNotEqualNumbers");
if (Math.abs((double)notExpected - (double)actual) <= (double)delta)
{
Assert.HandleFail("Assert.AreNotEqualNumbers", message, parameters);
}
}
public static void AreNotEqual(string notExpected, string actual, bool ignoreCase, CultureInfo culture, string message, params object[] parameters)
{
Assert.CheckParameterNotNull((object)culture, "Assert.AreNotEqual", "culture", string.Empty, new object[0]);
if (string.Compare(notExpected, actual, ignoreCase, culture) != 0)
{
return;
}
Assert.HandleFail("Assert.AreNotEqual", (string)FrameworkMessages.AreNotEqualFailMsg(message == null ? (object)string.Empty : (object)Assert.ReplaceNulls((object)message), (object)Assert.ReplaceNulls((object)notExpected), (object)Assert.ReplaceNulls((object)actual)), parameters);
}
/// <summary>
/// Tests whether the specified string ends with the specified substring
/// and throws an exception if the test string does not end with the
/// substring.
/// </summary>
/// <param name="value">
/// The string that is expected to end with <paramref name="substring"/>.
/// </param>
/// <param name="substring">
/// The string expected to be a suffix of <paramref name="value"/>.
/// </param>
/// <param name="message">
/// The message to include in the exception when <paramref name="value"/>
/// does not end with <paramref name="substring"/>. The message is
/// shown in test results.
/// </param>
/// <param name="comparisonType">
/// The comparison method to compare strings <paramref name="comparisonType"/>.
/// </param>
/// <param name="parameters">
/// An array of parameters to use when formatting <paramref name="message"/>.
/// </param>
/// <exception cref="AssertFailedException">
/// Thrown if <paramref name="value"/> does not end with
/// <paramref name="substring"/>.
/// </exception>
public static void EndsWith(string value, string substring, string message, StringComparison comparisonType, params object[] parameters)
{
Assert.CheckParameterNotNull(value, "StringAssert.EndsWith", "value", string.Empty);
Assert.CheckParameterNotNull(substring, "StringAssert.EndsWith", "substring", string.Empty);
if (!value.EndsWith(substring, comparisonType))
{
string finalMessage = string.Format(CultureInfo.CurrentCulture, FrameworkMessages.EndsWithFail, value, substring, message);
Assert.HandleFail("StringAssert.EndsWith", finalMessage, parameters);
}
}
/// <summary>
/// Tests whether the specified string contains the specified substring
/// and throws an exception if the substring does not occur within the
/// test string.
/// </summary>
/// <param name="value">
/// The string that is expected to contain <paramref name="substring"/>.
/// </param>
/// <param name="substring">
/// The string expected to occur within <paramref name="value"/>.
/// </param>
/// <param name="message">
/// The message to include in the exception when <paramref name="substring"/>
/// is not in <paramref name="value"/>. The message is shown in
/// test results.
/// </param>
/// <param name="parameters">
/// An array of parameters to use when formatting <paramref name="message"/>.
/// </param>
/// <exception cref="AssertFailedException">
/// Thrown if <paramref name="substring"/> is not found in
/// <paramref name="value"/>.
/// </exception>
public static void Contains(string value, string substring, string message, params object[] parameters)
{
Assert.CheckParameterNotNull(value, "StringAssert.Contains", "value", string.Empty);
Assert.CheckParameterNotNull(substring, "StringAssert.Contains", "substring", string.Empty);
if (value.IndexOf(substring, StringComparison.Ordinal) < 0)
{
string finalMessage = string.Format(CultureInfo.CurrentCulture, FrameworkMessages.ContainsFail, value, substring, message);
Assert.HandleFail("StringAssert.Contains", finalMessage, parameters);
}
}
/// <summary>
/// Tests whether the specified string ends with the specified substring
/// and throws an exception if the test string does not end with the
/// substring.
/// </summary>
/// <param name="value">
/// The string that is expected to end with <paramref name="substring"/>.
/// </param>
/// <param name="substring">
/// The string expected to be a suffix of <paramref name="value"/>.
/// </param>
/// <param name="message">
/// The message to include in the exception when <paramref name="value"/>
/// does not end with <paramref name="substring"/>. The message is
/// shown in test results.
/// </param>
/// <param name="parameters">
/// An array of parameters to use when formatting <paramref name="message"/>.
/// </param>
/// <exception cref="AssertFailedException">
/// Thrown if <paramref name="value"/> does not end with
/// <paramref name="substring"/>.
/// </exception>
public static void EndsWith(string value, string substring, string message, params object[] parameters)
{
Assert.CheckParameterNotNull(value, "StringAssert.EndsWith", "value", string.Empty);
Assert.CheckParameterNotNull(substring, "StringAssert.EndsWith", "substring", string.Empty);
if (!value.EndsWith(substring, StringComparison.Ordinal))
{
string finalMessage = FrameworkMessages.EndsWithFail(value, substring, message);
Assert.HandleFail("StringAssert.EndsWith", finalMessage, parameters);
}
}
/// <summary>
/// Tests whether the specified string matches a regular expression and
/// throws an exception if the string does not match the expression.
/// </summary>
/// <param name="value">
/// The string that is expected to match <paramref name="pattern"/>.
/// </param>
/// <param name="pattern">
/// The regular expression that <paramref name="value"/> is
/// expected to match.
/// </param>
/// <param name="message">
/// The message to include in the exception when <paramref name="value"/>
/// does not match <paramref name="pattern"/>. The message is shown in
/// test results.
/// </param>
/// <param name="parameters">
/// An array of parameters to use when formatting <paramref name="message"/>.
/// </param>
/// <exception cref="AssertFailedException">
/// Thrown if <paramref name="value"/> does not match
/// <paramref name="pattern"/>.
/// </exception>
public static void Matches(string value, Regex pattern, string message, params object[] parameters)
{
Assert.CheckParameterNotNull(value, "StringAssert.Matches", "value", string.Empty);
Assert.CheckParameterNotNull(pattern, "StringAssert.Matches", "pattern", string.Empty);
if (!pattern.IsMatch(value))
{
string finalMessage = FrameworkMessages.IsMatchFail(value, pattern, message);
Assert.HandleFail("StringAssert.Matches", finalMessage, parameters);
}
}
/// <summary>
/// Tests whether the specified string does not match a regular expression
/// and throws an exception if the string matches the expression.
/// </summary>
/// <param name="value">
/// The string that is expected not to match <paramref name="pattern"/>.
/// </param>
/// <param name="pattern">
/// The regular expression that <paramref name="value"/> is
/// expected to not match.
/// </param>
/// <param name="message">
/// The message to include in the exception when <paramref name="value"/>
/// matches <paramref name="pattern"/>. The message is shown in test
/// results.
/// </param>
/// <param name="parameters">
/// An array of parameters to use when formatting <paramref name="message"/>.
/// </param>
/// <exception cref="AssertFailedException">
/// Thrown if <paramref name="value"/> matches <paramref name="pattern"/>.
/// </exception>
public static void DoesNotMatch(string value, Regex pattern, string message, params object[] parameters)
{
Assert.CheckParameterNotNull(value, "StringAssert.DoesNotMatch", "value", string.Empty);
Assert.CheckParameterNotNull(pattern, "StringAssert.DoesNotMatch", "pattern", string.Empty);
if (pattern.IsMatch(value))
{
string finalMessage = string.Format(CultureInfo.CurrentCulture, FrameworkMessages.IsNotMatchFail, value, pattern, message);
Assert.HandleFail("StringAssert.DoesNotMatch", finalMessage, parameters);
}
}
public static void IsNotInstanceOfType(object value, Type wrongType, string message, params object[] parameters)
{
if (wrongType == (Type)null)
{
Assert.HandleFail("Assert.IsNotInstanceOfType", message, parameters);
}
if (value == null || !wrongType.IsInstanceOfType(value))
{
return;
}
Assert.HandleFail("Assert.IsNotInstanceOfType", (string)FrameworkMessages.IsNotInstanceOfFailMsg(message == null ? (object)string.Empty : (object)Assert.ReplaceNulls((object)message), (object)wrongType.ToString(), (object)value.GetType().ToString()), parameters);
}
public static void AreSame(object expected, object actual, string message, params object[] parameters)
{
if (object.ReferenceEquals(expected, actual))
{
return;
}
string message1 = message;
if (expected is ValueType && actual is ValueType)
{
message1 = (string)FrameworkMessages.AreSameGivenValues(message == null ? (object)string.Empty : (object)Assert.ReplaceNulls((object)message));
}
Assert.HandleFail("Assert.AreSame", message1, parameters);
}
private static void NumericPreAssert(INumber target, INumber actual, string methodName)
{
if (!target.HasValue())
{
Assert.HandleFail(methodName, "The target value cannot be null or undefined.", null);
}
if (!actual.HasValue())
{
Assert.HandleFail(methodName, "The actual value cannot be null or undefined.", null);
}
if (window.isNaN(target))
{
Assert.HandleFail(methodName, "The target value must be a valid number.", null);
}
if (window.isNaN(actual))
{
Assert.HandleFail(methodName, "The actual value must be a valid number.", null);
}
}
/// <summary>
/// Verifies that two strings are not equal.
/// </summary>
/// <param name="notExpected">The unexpected value.</param>
/// <param name="actual">The actual value.</param>
/// <param name="ignoreCase">True to ignore case, false otherwise.</param>
/// <param name="message">The failure message.</param>
/// <param name="parameters">The message parameters.</param>
public static void AreNotEqualStrings(string notExpected, string actual, bool ignoreCase = false, string message = null, object[] parameters = null)
{
StringPreAssert(notExpected, actual, "Assert.AreNotEqualStrings");
if (ignoreCase)
{
var targetLowered = (notExpected != null) ? notExpected.toLowerCase() : null;
var actualLowered = (actual != null) ? actual.toLowerCase() : null;
if (targetLowered == actualLowered)
{
Assert.HandleFail("Assert.AreNotEqualStrings", message, parameters);
}
}
else
{
if (notExpected == actual)
{
Assert.HandleFail("Assert.AreNotEqualStrings", message, parameters);
}
}
}
public static void Fail(string message, params object[] parameters)
{
Assert.HandleFail("Assert.Fail", message, parameters);
}
