ImageSharp/tests/ImageSharp.Tests/Helpers/TolerantMathTests.cs

// Copyright (c) Six Labors.
// Licensed under the Six Labors Split License.


// ReSharper disable InconsistentNaming
namespace SixLabors.ImageSharp.Tests.Helpers;

public class TolerantMathTests
{
    private readonly TolerantMath tolerantMath = new(0.1);

    [Theory]
    [InlineData(0)]
    [InlineData(0.01)]
    [InlineData(-0.05)]
    public void IsZero_WhenTrue(double a)
    {
        Assert.True(this.tolerantMath.IsZero(a));
    }

    [Theory]
    [InlineData(0.11)]
    [InlineData(-0.101)]
    [InlineData(42)]
    public void IsZero_WhenFalse(double a)
    {
        Assert.False(this.tolerantMath.IsZero(a));
    }

    [Theory]
    [InlineData(0.11)]
    [InlineData(100)]
    public void IsPositive_WhenTrue(double a)
    {
        Assert.True(this.tolerantMath.IsPositive(a));
    }

    [Theory]
    [InlineData(0.09)]
    [InlineData(-0.1)]
    [InlineData(-1000)]
    public void IsPositive_WhenFalse(double a)
    {
        Assert.False(this.tolerantMath.IsPositive(a));
    }

    [Theory]
    [InlineData(-0.11)]
    [InlineData(-100)]
    public void IsNegative_WhenTrue(double a)
    {
        Assert.True(this.tolerantMath.IsNegative(a));
    }

    [Theory]
    [InlineData(-0.09)]
    [InlineData(0.1)]
    [InlineData(1000)]
    public void IsNegative_WhenFalse(double a)
    {
        Assert.False(this.tolerantMath.IsNegative(a));
    }

    [Theory]
    [InlineData(4.2, 4.2)]
    [InlineData(4.2, 4.25)]
    [InlineData(-Math.PI, -Math.PI + 0.05)]
    [InlineData(999999.2, 999999.25)]
    public void AreEqual_WhenTrue(double a, double b)
    {
        Assert.True(this.tolerantMath.AreEqual(a, b));
    }

    [Theory]
    [InlineData(1, 2)]
    [InlineData(-1000000, -1000000.2)]
    public void AreEqual_WhenFalse(double a, double b)
    {
        Assert.False(this.tolerantMath.AreEqual(a, b));
    }

    [Theory]
    [InlineData(2, 1.8)]
    [InlineData(-20, -20.2)]
    [InlineData(0.1, -0.1)]
    [InlineData(100, 10)]
    public void IsGreater_IsLess_WhenTrue(double a, double b)
    {
        Assert.True(this.tolerantMath.IsGreater(a, b));
        Assert.True(this.tolerantMath.IsLess(b, a));
    }

    [Theory]
    [InlineData(2, 1.95)]
    [InlineData(-20, -20.02)]
    [InlineData(0.01, -0.01)]
    [InlineData(999999, 999999.09)]
    public void IsGreater_IsLess_WhenFalse(double a, double b)
    {
        Assert.False(this.tolerantMath.IsGreater(a, b));
        Assert.False(this.tolerantMath.IsLess(b, a));
    }

    [Theory]
    [InlineData(3, 2)]
    [InlineData(3, 2.99)]
    [InlineData(2.99, 3)]
    [InlineData(-5, -6)]
    [InlineData(-5, -5.05)]
    [InlineData(-5.05, -5)]
    public void IsGreaterOrEqual_IsLessOrEqual_WhenTrue(double a, double b)
    {
        Assert.True(this.tolerantMath.IsGreaterOrEqual(a, b));
        Assert.True(this.tolerantMath.IsLessOrEqual(b, a));
    }

    [Theory]
    [InlineData(2, 3)]
    [InlineData(2.89, 3)]
    [InlineData(-3, -2.89)]
    public void IsGreaterOrEqual_IsLessOrEqual_WhenFalse(double a, double b)
    {
        Assert.False(this.tolerantMath.IsGreaterOrEqual(a, b));
        Assert.False(this.tolerantMath.IsLessOrEqual(b, a));
    }

    [Theory]
    [InlineData(3.5, 4.0)]
    [InlineData(3.89, 4.0)]
    [InlineData(4.09, 4.0)]
    [InlineData(4.11, 5.0)]
    [InlineData(0.11, 1)]
    [InlineData(0.05, 0)]
    [InlineData(-0.5, 0)]
    [InlineData(-0.95, -1)]
    [InlineData(-1.05, -1)]
    [InlineData(-1.5, -1)]
    public void Ceiling(double value, double expected)
    {
        double actual = this.tolerantMath.Ceiling(value);
        Assert.Equal(expected, actual);
    }

    [Theory]
    [InlineData(1, 1)]
    [InlineData(0.99, 1)]
    [InlineData(0.5, 0)]
    [InlineData(0.01, 0)]
    [InlineData(-0.09, 0)]
    [InlineData(-0.11, -1)]
    [InlineData(-100.11, -101)]
    [InlineData(-100.09, -100)]
    public void Floor(double value, double expected)
    {
        double plz1 = Math.IEEERemainder(1.1, 1);
        double plz2 = Math.IEEERemainder(0.9, 1);

        double plz3 = Math.IEEERemainder(-1.1, 1);
        double plz4 = Math.IEEERemainder(-0.9, 1);

        double actual = this.tolerantMath.Floor(value);
        Assert.Equal(expected, actual);
    }
}