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)}"); } /// At least one element satisfies . public static T Contains(IEnumerable collection, Func predicate, [CallerArgumentExpression(nameof(predicate))] string? expression = null) { foreach (var item in collection) { if (predicate(item)) return item; } Fail($"No element matches {expression}"); return default!; } 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, }; }