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);
    }
}