BadNUnitAssertApi.cs

Go to the documentation of this file.

using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Native;
 
using NUnit.Framework;
 
namespace BadScript2.Interop.NUnit;
 
[BadInteropApi("Assert")]
internal partial class BadNUnitAssertApi
{
    [BadMethod("Throws", "Asserts that the given function throws a BadRuntimeException")]
    private static void Assert_Throws(
        BadExecutionContext ctx,
        [BadParameter(description: "The Function that is expected to throw")]
        BadFunction func,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.Throws<BadRuntimeException>(
            () =>
            {
                foreach (BadObject _ in func.Invoke(Array.Empty<BadObject>(), ctx))
                {
                    //Do Nothing
                }
            },
            message
        );
    }
 
    [BadMethod("AreEqual", "Asserts that the given objects are equal")]
    private static void Assert_AreEqual(
        [BadParameter(description: "The Expected Value")]
        BadObject? expected,
        [BadParameter(description: "The Actual Value")]
        BadObject? actual,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(actual, Is.EqualTo(expected), message);
    }
 
    [BadMethod("AreNotEqual", "Asserts that the given objects are not equal")]
    private static void Assert_AreNotEqual(
        [BadParameter(description: "The Expected Value")]
        BadObject? expected,
        [BadParameter(description: "The Actual Value")]
        BadObject? actual,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(actual, Is.Not.EqualTo(expected), message);
    }
 
    [BadMethod("AreSame", "Asserts that the given objects are the same")]
    private static void Assert_AreSame(
        [BadParameter(description: "The Expected Value")]
        BadObject? expected,
        [BadParameter(description: "The Actual Value")]
        BadObject? actual,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(actual, Is.SameAs(expected), message);
    }
 
    [BadMethod("AreNotSame", "Asserts that the given objects are not the same")]
    private static void Assert_AreNotSame(
        [BadParameter(description: "The Expected Value")]
        BadObject? expected,
        [BadParameter(description: "The Actual Value")]
        BadObject? actual,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(actual, Is.Not.SameAs(expected), message);
    }
 
    [BadMethod("IsTrue", "Asserts that the given condition is true")]
    private static void Assert_IsTrue([BadParameter(description: "The Condition to check")] BadObject? condition, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(
            condition is IBadBoolean
            {
                Value: true,
            },
            Is.True,
            message
        );
    }
 
    [BadMethod("IsFalse", "Asserts that the given condition is false")]
    private static void Assert_IsFalse([BadParameter(description: "The Condition to check")] BadObject? condition, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(condition is not IBadBoolean b || b.Value, Is.False, message);
    }
 
 
    [BadMethod("Fail", "Fails the test with the given message")]
    private static void Assert_Fail([BadParameter(description: "The Message")] string message)
    {
        Assert.Fail(message);
    }
 
    [BadMethod("Inconclusive", "Marks the test as inconclusive with the given message")]
    private static void Assert_Inconclusive([BadParameter(description: "The Message")] string message)
    {
        Assert.Inconclusive(message);
    }
 
    [BadMethod("Ignore", "Ignore the test with the given message")]
    private static void Assert_Ignore([BadParameter(description: "The Message")] string message)
    {
        Assert.Ignore(message);
    }
 
 
    [BadMethod("IsNull", "Asserts that the given object is null")]
    private static void Assert_IsNull([BadParameter(description: "The Object to check")] BadObject? obj, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(obj, Is.Null, message);
    }
 
    [BadMethod("IsNotNull", "Asserts that the given object is not null")]
    private static void Assert_IsNotNull([BadParameter(description: "The Object to check")] BadObject? obj, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(obj, Is.Not.Null, message);
    }
 
    [BadMethod("Greater", "Asserts that the given object is greater than the other object")]
    private static void Assert_Greater(
        [BadParameter(description: "Actual")] decimal a,
        [BadParameter(description: "Expected")]
        decimal b,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(a, Is.GreaterThan(b), message);
    }
 
    [BadMethod("GreaterOrEqual", "Asserts that the given object is greater or equal the other object")]
    private static void Assert_GreaterOrEqual(
        [BadParameter(description: "Actual")] decimal a,
        [BadParameter(description: "Expected")]
        decimal b,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(a, Is.GreaterThanOrEqualTo(b), message);
    }
 
    [BadMethod("Less", "Asserts that the given object is less than the other object")]
    private static void Assert_Less(
        [BadParameter(description: "Actual")] decimal a,
        [BadParameter(description: "Expected")]
        decimal b,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(a, Is.LessThan(b), message);
    }
 
    [BadMethod("LessOrEqual", "Asserts that the given object is less or equal the other object")]
    private static void Assert_LessOrEqual(
        [BadParameter(description: "Actual")] decimal a,
        [BadParameter(description: "Expected")]
        decimal b,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(a, Is.LessThanOrEqualTo(b), message);
    }
 
    [BadMethod("Contains", "Asserts that the given collection contains the given object")]
    private static void Assert_Contains(
        [BadParameter(description: "The Collection to Check")]
        BadArray collection,
        [BadParameter(description: "The Object to Check")]
        BadObject? obj,
        [BadParameter(description: "The Message")]
        string message)
    {
        Assert.That(collection.InnerArray, Contains.Value(obj!), message);
    }
 
 
    [BadMethod("Positive", "Asserts that the given object is positive")]
    private static void Assert_Positive([BadParameter(description: "The Object to Check")] decimal d, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(d, Is.Positive);
    }
 
    [BadMethod("Negative", "Asserts that the given object is negative")]
    private static void Assert_Negative([BadParameter(description: "The Object to Check")] decimal d, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(d, Is.Negative);
    }
 
    [BadMethod("Zero", "Asserts that the given object is zero")]
    private static void Assert_Zero([BadParameter(description: "The Object to Check")] decimal d, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(d, Is.Zero);
    }
 
    [BadMethod("NotZero", "Asserts that the given object is not zero")]
    private static void Assert_NotZero([BadParameter(description: "The Object to Check")] decimal d, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(d, Is.Not.Zero);
    }
 
    [BadMethod("Pass", "Passes the test with the given message")]
    private static void Assert_Pass([BadParameter(description: "The Message")] string message)
    {
        Assert.Pass(message);
    }
 
    [BadMethod("IsEmpty", "Asserts that the given collection is empty")]
    private static void Assert_IsEmpty([BadParameter(description: "The Collection to Check")] BadArray collection, [BadParameter(description: "The Message")] string message)
    {
        Assert.That(collection.InnerArray, Is.Empty, message);
    }
}