Add tests for Rgba128

tests/ImageSharp.Tests/PixelFormats/Rgba128Tests.cs

@@ -0,0 +1,313 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Tests.PixelFormats;
+
+[Trait("Category", "PixelFormats")]
+public class Rgba128Tests
+{
+    [Theory]
+    [InlineData(1, 2, 3, 4)]
+    [InlineData(50, 70, 80, 90)]
+    [InlineData(1000, 2000, 3000, 4000)]
+    public void Constructor(uint r, uint g, uint b, uint a)
+    {
+        Rgba128 p = new(r, g, b, a);
+
+        Assert.Equal(r, p.R);
+        Assert.Equal(g, p.G);
+        Assert.Equal(b, p.B);
+    }
+
+    [Fact]
+    public void Rgba128_ToVector4()
+    {
+        Assert.Equal(Vector4.Zero, new Rgba128(0, 0, 0, 0).ToVector4());
+        Assert.Equal(Vector4.One, new Rgba128(uint.MaxValue, uint.MaxValue, uint.MaxValue, uint.MaxValue).ToVector4());
+        Assert.Equal(new Vector4(0.5F, 0.5F, 0.5F, 0.5F), new Rgba128(uint.MaxValue / 2, uint.MaxValue / 2, uint.MaxValue / 2, uint.MaxValue / 2).ToVector4());
+    }
+
+    [Theory]
+    [InlineData(uint.MaxValue, uint.MaxValue, uint.MaxValue, uint.MaxValue)]
+    [InlineData(0, 0, 0, 0)]
+    [InlineData(uint.MaxValue / 2, 100, 2222, 3333)]
+    public void Rgba128_ToScaledVector4(uint r, uint g, uint b, uint a)
+    {
+        // arrange
+        Rgba128 rgb = new(r, g, b, a);
+
+        float max = uint.MaxValue;
+        float rr = r / max;
+        float gg = g / max;
+        float bb = b / max;
+        float aa = a / max;
+
+        // act
+        Vector4 actual = rgb.ToScaledVector4();
+
+        // assert
+        Assert.Equal(rr, actual.X);
+        Assert.Equal(gg, actual.Y);
+        Assert.Equal(bb, actual.Z);
+        Assert.Equal(aa, actual.W);
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 0)]
+    [InlineData(5000, 100, 2222, 3333)]
+    public void Rgba128_FromScaledVector4(uint r, uint g, uint b, uint a)
+    {
+        // arrange
+        Rgba128 source = new(r, g, b, a);
+        Vector4 scaled = source.ToScaledVector4();
+
+        // act
+        Rgba128 actual = Rgba128.FromScaledVector4(scaled);
+
+        // assert
+        Assert.Equal(source, actual);
+    }
+
+    [Fact]
+    public void Rgba128_ToRgba32()
+    {
+        // arrange
+        Rgba128 rgb96 = new((uint)(uint.MaxValue * 0.1f), uint.MaxValue / 2, uint.MaxValue, uint.MaxValue);
+        Rgba32 expected = new(25, 127, 255, 255);
+
+        // act
+        Rgba32 actual = rgb96.ToRgba32();
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Equality_WhenTrue()
+    {
+        Rgba128 c1 = new(100, 2000, 3000, 4000);
+        Rgba128 c2 = new(100, 2000, 3000, 4000);
+
+        Assert.True(c1.Equals(c2));
+        Assert.True(c1.GetHashCode() == c2.GetHashCode());
+    }
+
+    [Fact]
+    public void Equality_WhenFalse()
+    {
+        Rgba128 c1 = new(100, 2000, 3000, 4000);
+        Rgba128 c2 = new(101, 2000, 3000, 4000);
+        Rgba128 c3 = new(100, 2000, 3001, 4000);
+
+        Assert.False(c1.Equals(c2));
+        Assert.False(c2.Equals(c3));
+        Assert.False(c3.Equals(c1));
+    }
+
+    [Fact]
+    public void Rgba128_FromRgba32()
+    {
+        // arrange
+        Rgba32 source = new(25, 127, 255, 255);
+        Rgba128 expected = new(421075225, 2139062143, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromRgba32(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromRgb24()
+    {
+        // arrange
+        Rgb24 source = new(25, 127, 255);
+        Rgba128 expected = new(421075225, 2139062143, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromRgb24(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromRgb48()
+    {
+        // arrange
+        Rgb48 source = new(0, 32767, ushort.MaxValue);
+        Rgba128 expected = new(0, 2147450879, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromRgb48(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromRgba64()
+    {
+        // arrange
+        Rgba64 source = new(0, 32767, ushort.MaxValue, ushort.MaxValue);
+        Rgba128 expected = new(0, 2147450879, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromRgba64(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromLa32()
+    {
+        // arrange
+        La32 source = new(32767, ushort.MaxValue);
+        Rgba128 expected = new(2147450879, 2147450879, 2147450879, 2147450879);
+
+        // act
+        Rgba128 actual = Rgba128.FromLa32(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromLa16()
+    {
+        // arrange
+        La16 source = new(127, byte.MaxValue);
+        Rgba128 expected = new(2139062143, 2139062143, 2139062143, 2139062143);
+
+        // act
+        Rgba128 actual = Rgba128.FromLa16(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromL16()
+    {
+        // arrange
+        L16 source = new(32767);
+        Rgba128 expected = new(2147450879, 2147450879, 2147450879, 2147450879);
+
+        // act
+        Rgba128 actual = Rgba128.FromL16(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromL8()
+    {
+        // arrange
+        L8 source = new(127);
+        Rgba128 expected = new(2139062143, 2139062143, 2139062143, 2139062143);
+
+        // act
+        Rgba128 actual = Rgba128.FromL8(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromBgra32()
+    {
+        // arrange
+        Bgra32 source = new(127, 25, 255);
+        Rgba128 expected = new(2139062143, 421075225, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromBgra32(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromBgr24()
+    {
+        // arrange
+        Bgr24 source = new(127, 25, 255);
+        Rgba128 expected = new(2139062143, 421075225, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromBgr24(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromBgra5551()
+    {
+        // arrange
+        Bgra5551 source = new(1.0f, 1.0f, 1.0f, 1.0f);
+        Rgba128 expected = new(uint.MaxValue, uint.MaxValue, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromBgra5551(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromArgb32()
+    {
+        // arrange
+        Argb32 source = new(127, 25, 255);
+        Rgba128 expected = new(2139062143, 421075225, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromArgb32(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_FromAbgr32()
+    {
+        // arrange
+        Abgr32 source = new(127, 25, 255);
+        Rgba128 expected = new(2139062143, 421075225, uint.MaxValue, uint.MaxValue);
+
+        // act
+        Rgba128 actual = Rgba128.FromAbgr32(source);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Rgba128_PixelInformation()
+    {
+        PixelTypeInfo info = Rgba128.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgba128>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo? maybeComponentInfo = info.ComponentInfo;
+        Assert.NotNull(maybeComponentInfo);
+        PixelComponentInfo componentInfo = maybeComponentInfo.Value;
+
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(32, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(32, componentInfo.GetMaximumComponentPrecision());
+    }
+}