Replace NUnit Assert with the custom verification logic to imrpove performance and avoid NUnit dependency

[dadhi]

In regard to the testing and using of NUnit as a testing library, the only thing in use right now is its Assert facilities
e.g.:

• I am using custom test runner and debugging of the tests with...TestRunner CLI program instead of relying on the NUnit runner.
• I am not using the test coverage (In the future, I would rather use fuzzing instead).

Right now I need a rather simple or much more complex custom verification (for the generated OpCodes) instead of the generic Assert.
So by cutting this last used NUnit feature, I will remove the dependency altogether, speeding up the compilation and simplifying the solution

My Assert replacing would probably be like:

• Using CallerArgumentExpression to quickly understand the failed condition.
• Won't throw the Exception on failure but rather will return false. It should speed up the test run given how many Asserts the test suite has (1753 at 2025.03.07). Ackshually... the test is expected to either pass or fail, and the tests in general have a flat structure, so why use Exception to propagate the failure???

[dadhi]

More thoughts:

"Normally" having multiple Asserts is considered problematic, because of the idea that the test should test a single thing, so it should be somehow translated to the verifying a single thing only. Talking about the Unit tests...

But in reality it is often useful to check multiple assumptions in a row, especially for the integration, realistic, end-to-end tests.

Now, the usual implementation of the Assert throws the AssertException making the latter Asserts un-evaluated.
This minimizes the amount of info provided on error, and wastes the time of rerunning the tests with turning the Asserts on/off along the way.

I propose for my Asserts to be bound to the test execution context.
So all asserts are evaluated until the end of the test, writing the errors into the context.
The whole state of context after the test describes all errors.

This approach removes the Exception-per-Assert, therefore improves the performance of the test and provides more info to find the problem.

Additionally the Asserts may and probably should return the result as true or false, so the User may decide on the further logic based on this result, e.g. returning earlier.

[dadhi]

The prototype (done on #451):

    public struct FooBarTests : ITest
    {
        // todo: @wip `t` should be passed with the name of the test and its file set externally
        public void Run(TestRunContext t)
        {
            TestFoo(t);
            TestBar(t);
        }

        public void TestFoo(TestMethodContext t)
        {
            t.IsTrue(false);
            t.Fails("Not implemented");
        }

        public void TestBar(TestMethodContext t)
        {
            t.Fails("Not implemented");
        }
    }

    public interface ITest
    {
        void Run(TestRunContext t);
    }

    public static class TestRunner
    {
        // returns number of the tests
        public static int Run()
        {
            var ctx = new TestRunContext();

            ctx.Run(new FooBarTests());

            return ctx.TotalTestCount;
        }
    }

    public record struct TestFailure(
        string TestName, int SourceLineNumber,
        AssertKind Kind,
        object actual, string actualName,
        object optionalExpected, string optionalExpectedName);

    public record struct TestStats(
        string TestsName, string TestsFile,
        Exception TestStopException, int TestCount, Range FailuresRange);

    public enum TestRunTracking
    {
        TrackOnlyFailedTests = 0,
        TrackAllTests,
    }

    // Per-thread context
    public sealed class TestRunContext
    {
        public void Run(ITest test, TestRunTracking tracking = TestRunTracking.TrackOnlyFailedTests)
        {
            var totalTestCount = TotalTestCount;
            var failuresCount = FailuresCount;
            Exception testStopException = null;
            try
            {
                test.Run(this);
            }
            catch (Exception ex)
            {
                testStopException = ex;
            }

            // todo: @wip is there a more performant way to get the test name and file?
            if (testStopException != null ||
                tracking == TestRunTracking.TrackAllTests ||
                tracking == TestRunTracking.TrackOnlyFailedTests & failuresCount < FailuresCount)
            {
                var testsType = test.GetType();
                var testsName = testsType.Name;
                var testsFile = new Uri(testsType.Assembly.Location).LocalPath;

                var testCount = TotalTestCount - totalTestCount;
                var failuresRange = failuresCount..FailuresCount;

                var stats = new TestStats(testsName, testsFile, testStopException, testCount, failuresRange);
                Stats.Add(stats);
            }
        }

        // Stats gathered while running with each failed assertion
        public int TotalTestCount;
        public int FailuresCount;
        public List<TestStats> Stats = new();
        public List<TestFailure> Failures = new();
    }

    public enum AssertKind
    {
        CommandedToFail,
        IsTrue,
        IsFalse,
        AreEqual,
        AreNotEqual,
        Throws,
    }

    // Wrapper for the context per test method
    public struct TestMethodContext
    {
        public readonly TestRunContext TestRunContext;
        public TestMethodContext(TestRunContext testRunContext) => TestRunContext = testRunContext;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator TestMethodContext(TestRunContext t)
        {
            // A trick to automatically increment the test count when passing context to the test method
            t.TotalTestCount += 1;
            return new TestMethodContext(t);
        }

        /// <summary>Always failes with the provided message</summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Fails(string message,
            [CallerMemberName] string testName = "",
            [CallerLineNumber] int sourceLineNumber = 0)
        {
            var failure = new TestFailure(testName, sourceLineNumber, AssertKind.CommandedToFail, null, message, null, null);
            TestRunContext.Failures.Add(failure);
        }

        /// <summary>Method returns the Assert result to ptentially be used by the User for the latter test logic, e.g. returning early</summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool IsTrue(bool actual,
            [CallerArgumentExpression(nameof(actual))] string actualName = "actual",
            [CallerMemberName] string testName = "",
            [CallerLineNumber] int sourceLineNumber = 0)
        {
            if (actual)
                return true;

            var failure = new TestFailure(testName, sourceLineNumber, AssertKind.IsTrue, actual, actualName, null, null);
            TestRunContext.Failures.Add(failure);
            return false;
        }
    }