using System.Collections;
using System.Globalization;
using System.Runtime.CompilerServices;
namespace Titano.Testing;
/// Assertions with messages that state expected and actual values.
public static class Assert
{
public static void True([System.Diagnostics.CodeAnalysis.DoesNotReturnIf(false)] bool condition, string? message = null, [CallerArgumentExpression(nameof(condition))] string? expression = null)
{
if (!condition) Fail(message ?? $"Expected true: {expression}");
}
public static void False([System.Diagnostics.CodeAnalysis.DoesNotReturnIf(true)] bool condition, string? message = null, [CallerArgumentExpression(nameof(condition))] string? expression = null)
{
if (condition) Fail(message ?? $"Expected false: {expression}");
}
public static void Null(object? value, [CallerArgumentExpression(nameof(value))] string? expression = null)
{
if (value is not null) Fail($"Expected null: {expression} was {Format(value)}");
}
public static T NotNull([System.Diagnostics.CodeAnalysis.NotNull] T? value, [CallerArgumentExpression(nameof(value))] string? expression = null) where T : class
{
if (value is null) Fail($"Expected non-null: {expression}");
return value!;
}
public static T NotNull([System.Diagnostics.CodeAnalysis.NotNull] T? value, [CallerArgumentExpression(nameof(value))] string? expression = null) where T : struct
{
if (value is null) Fail($"Expected non-null: {expression}");
return value!.Value;
}
public static void Equal(T expected, T actual, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (!EqualityComparer.Default.Equals(expected, actual))
Fail(Prefix(message) + $"{expression}: expected {Format(expected)}, actual {Format(actual)}");
}
public static void NotEqual(T unexpected, T actual, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (EqualityComparer.Default.Equals(unexpected, actual))
Fail(Prefix(message) + $"{expression}: did not expect {Format(unexpected)}");
}
public static void Same(object? expected, object? actual, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (!ReferenceEquals(expected, actual)) Fail($"{expression}: expected the same instance");
}
/// |expected − actual| ≤ tolerance.
public static void Approximately(double expected, double actual, double tolerance, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (double.IsNaN(actual) || Math.Abs(expected - actual) > tolerance)
Fail(Prefix(message) + $"{expression}: expected {F(expected)} ± {F(tolerance)}, actual {F(actual)} (diff {F(Math.Abs(expected - actual))})");
}
/// Distance between two points ≤ .
public static void Within(double expectedX, double expectedY, double actualX, double actualY, double pixels, string? message = null)
{
var d = Math.Sqrt((expectedX - actualX) * (expectedX - actualX) + (expectedY - actualY) * (expectedY - actualY));
if (!(d <= pixels))
Fail(Prefix(message) + $"expected ({F(expectedX)}, {F(expectedY)}) within {F(pixels)} px, actual ({F(actualX)}, {F(actualY)}) at {F(d)} px");
}
public static void InRange(double actual, double min, double max, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (!(actual >= min && actual <= max))
Fail(Prefix(message) + $"{expression}: expected in [{F(min)}, {F(max)}], actual {F(actual)}");
}
public static void Greater(double actual, double bound, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (!(actual > bound)) Fail(Prefix(message) + $"{expression}: expected > {F(bound)}, actual {F(actual)}");
}
public static void GreaterOrEqual(double actual, double bound, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (!(actual >= bound)) Fail(Prefix(message) + $"{expression}: expected ≥ {F(bound)}, actual {F(actual)}");
}
public static void Less(double actual, double bound, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (!(actual < bound)) Fail(Prefix(message) + $"{expression}: expected < {F(bound)}, actual {F(actual)}");
}
public static void LessOrEqual(double actual, double bound, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (!(actual <= bound)) Fail(Prefix(message) + $"{expression}: expected ≤ {F(bound)}, actual {F(actual)}");
}
public static void SequenceEqual(IEnumerable expected, IEnumerable actual, string? message = null, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
var e = expected.ToList();
var a = actual.ToList();
var n = Math.Min(e.Count, a.Count);
for (var i = 0; i < n; i++)
{
if (!EqualityComparer.Default.Equals(e[i], a[i]))
Fail(Prefix(message) + $"{expression}: first difference at [{i}]: expected {Format(e[i])}, actual {Format(a[i])}");
}
if (e.Count != a.Count)
Fail(Prefix(message) + $"{expression}: expected {e.Count} items, actual {a.Count}");
}
public static void BytesEqual(ReadOnlySpan expected, ReadOnlySpan actual, string? message = null)
{
var n = Math.Min(expected.Length, actual.Length);
for (var i = 0; i < n; i++)
{
if (expected[i] != actual[i])
Fail(Prefix(message) + $"bytes differ at offset {i}: expected 0x{expected[i]:X2}, actual 0x{actual[i]:X2}");
}
if (expected.Length != actual.Length)
Fail(Prefix(message) + $"expected {expected.Length} bytes, actual {actual.Length}");
}
/// Every element is ≥ (or > when strict) the previous one.
public static void Monotonic(IEnumerable values, bool strict = false, bool decreasing = false, string? message = null)
{
var i = 0;
double? previous = null;
foreach (var v in values)
{
if (previous is { } p)
{
var ok = decreasing
? (strict ? v < p : v <= p)
: (strict ? v > p : v >= p);
if (!ok) Fail(Prefix(message) + $"not monotonic at [{i}]: {F(p)} then {F(v)}");
}
previous = v;
i++;
}
}
public static void Contains(T expected, IEnumerable collection, [CallerArgumentExpression(nameof(collection))] string? expression = null)
{
if (!collection.Contains(expected)) Fail($"{expression}: does not contain {Format(expected)}");
}
public static void DoesNotContain(T unexpected, IEnumerable collection, [CallerArgumentExpression(nameof(collection))] string? expression = null)
{
if (collection.Contains(unexpected)) Fail($"{expression}: unexpectedly contains {Format(unexpected)}");
}
public static void Contains(string expected, string? actual, [CallerArgumentExpression(nameof(actual))] string? expression = null)
{
if (actual is null || !actual.Contains(expected, StringComparison.Ordinal))
Fail($"{expression}: expected to contain \"{expected}\", actual {Format(actual)}");
}
public static void Empty(IEnumerable collection, [CallerArgumentExpression(nameof(collection))] string? expression = null)
{
foreach (var item in collection) Fail($"{expression}: expected empty, first item {Format(item)}");
}
public static void NotEmpty(IEnumerable collection, [CallerArgumentExpression(nameof(collection))] string? expression = null)
{
foreach (var _ in collection) return;
Fail($"{expression}: expected at least one item");
}
public static void Count(int expected, IEnumerable collection, [CallerArgumentExpression(nameof(collection))] string? expression = null)
{
var n = 0;
foreach (var _ in collection) n++;
if (n != expected) Fail($"{expression}: expected {expected} items, actual {n}");
}
public static TException Throws(Action action, [CallerArgumentExpression(nameof(action))] string? expression = null) where TException : Exception
{
try
{
action();
}
catch (TException ex)
{
return ex;
}
catch (Exception ex)
{
Fail($"{expression}: expected {typeof(TException).Name}, got {ex.GetType().Name}: {ex.Message}");
}
Fail($"{expression}: expected {typeof(TException).Name}, nothing was thrown");
return null!;
}
public static async Task ThrowsAsync(Func action, [CallerArgumentExpression(nameof(action))] string? expression = null) where TException : Exception
{
try
{
await action().ConfigureAwait(false);
}
catch (TException ex)
{
return ex;
}
catch (Exception ex)
{
Fail($"{expression}: expected {typeof(TException).Name}, got {ex.GetType().Name}: {ex.Message}");
}
Fail($"{expression}: expected {typeof(TException).Name}, nothing was thrown");
return null!;
}
public static void DoesNotThrow(Action action, [CallerArgumentExpression(nameof(action))] string? expression = null)
{
try
{
action();
}
catch (Exception ex)
{
Fail($"{expression}: unexpected {ex.GetType().Name}: {ex.Message}");
}
}
public static void FileExists(string path)
{
if (!File.Exists(path)) Fail($"File not found: {path}");
}
public static void FileMissing(string path)
{
if (File.Exists(path)) Fail($"File should not exist: {path}");
}
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
public static void Fail(string message) => throw new AssertionException(message);
[System.Diagnostics.CodeAnalysis.DoesNotReturn]
public static void Inconclusive(string reason) => throw new SkipException(reason);
private static string Prefix(string? message) => string.IsNullOrEmpty(message) ? string.Empty : message + ": ";
private static string F(double v) => v.ToString("G6", CultureInfo.InvariantCulture);
internal static string Format(object? value) => value switch
{
null => "null",
string s => "\"" + s + "\"",
double d => F(d),
float f => F(f),
IFormattable f => f.ToString(null, CultureInfo.InvariantCulture),
_ => value.ToString() ?? value.GetType().Name,
};
}