Add more pixel conversion tests

src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs

@@ -149,7 +149,7 @@ namespace SixLabors.ImageSharp.PixelFormats
         public override string ToString()
         {
             var vector = this.ToVector4();
-            return FormattableString.Invariant($"Bgra5551({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
+            return FormattableString.Invariant($"Byte4({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
         }
 
         /// <summary>

tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
@@ -9,6 +10,67 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Argb32Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Argb32(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Argb32(new Vector4(0.0f));
+            var color3 = new Argb32(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+            var color4 = new Argb32(1.0f, 0.0f, 1.0f, 1.0f);
+
+            Assert.Equal(color1, color2);
+            Assert.Equal(color3, color4);
+        }
+
+        /// <summary>
+        /// Tests the equality operators for inequality.
+        /// </summary>
+        [Fact]
+        public void AreNotEqual()
+        {
+            var color1 = new Argb32(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Argb32(new Vector4(1.0f));
+            var color3 = new Argb32(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new Argb32(1.0f, 1.0f, 0.0f, 1.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
+        /// <summary>
+        /// Tests whether the color constructor correctly assign properties.
+        /// </summary>
+        [Fact]
+        public void ConstructorAssignsProperties()
+        {
+            var color1 = new Argb32(1, .1f, .133f, .864f);
+            Assert.Equal(255, color1.R);
+            Assert.Equal((byte)Math.Round(.1f * 255), color1.G);
+            Assert.Equal((byte)Math.Round(.133f * 255), color1.B);
+            Assert.Equal((byte)Math.Round(.864f * 255), color1.A);
+
+            var color2 = new Argb32(1, .1f, .133f);
+            Assert.Equal(255, color2.R);
+            Assert.Equal(Math.Round(.1f * 255), color2.G);
+            Assert.Equal(Math.Round(.133f * 255), color2.B);
+            Assert.Equal(255, color2.A);
+
+            var color4 = new Argb32(new Vector3(1, .1f, .133f));
+            Assert.Equal(255, color4.R);
+            Assert.Equal(Math.Round(.1f * 255), color4.G);
+            Assert.Equal(Math.Round(.133f * 255), color4.B);
+            Assert.Equal(255, color4.A);
+
+            var color5 = new Argb32(new Vector4(1, .1f, .133f, .5f));
+            Assert.Equal(255, color5.R);
+            Assert.Equal(Math.Round(.1f * 255), color5.G);
+            Assert.Equal(Math.Round(.133f * 255), color5.B);
+            Assert.Equal(Math.Round(.5f * 255), color5.A);
+        }
+
         [Fact]
         public void Argb32_PackedValue()
         {

tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs

@@ -9,6 +9,24 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Bgr24Tests
     {
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
+            var color2 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
+            
+            Assert.Equal(color1, color2);
+        }
+
+        [Fact]
+        public void AreNotEqual()
+        {
+            var color1 = new Bgr24(byte.MaxValue, 0, 0);
+            var color2 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
+
+            Assert.NotEqual(color1, color2);
+        }
+
         public static readonly TheoryData<byte, byte, byte> ColorData =
             new TheoryData<byte, byte, byte>() { { 1, 2, 3 }, { 4, 5, 6 }, { 0, 255, 42 } };
 

tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
 using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;

tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
@@ -9,6 +10,30 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Bgra32Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+            var color2 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+            
+            Assert.Equal(color1, color2);
+        }
+
+        /// <summary>
+        /// Tests the equality operators for inequality.
+        /// </summary>
+        [Fact]
+        public void AreNotEqual()
+        {
+            var color1 = new Bgra32(0, 0, byte.MaxValue, byte.MaxValue);
+            var color2 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+
+            Assert.NotEqual(color1, color2);
+        }
+
         public static readonly TheoryData<byte, byte, byte, byte> ColorData =
             new TheoryData<byte, byte, byte, byte>()
                 {

tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs

@@ -75,6 +75,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(1, actual.W);
         }
 
+        [Fact]
+        public void Byte4_ToRgba32()
+        {
+            // arrange
+            var byte4 = new Byte4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+            var expected = new Rgba32(Vector4.One);
+            var actual = default(Rgba32);
+
+            // act
+            byte4.ToRgba32(ref actual);
+
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Byte4_FromScaledVector4()
         {

tests/ImageSharp.Tests/PixelFormats/Gray16Tests.cs

@@ -9,6 +9,24 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Gray16Tests
     {
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Gray16(3000);
+            var color2 = new Gray16(3000);
+
+            Assert.Equal(color1, color2);
+        }
+
+        [Fact]
+        public void AreNotEqual()
+        {
+            var color1 = new Gray16(12345);
+            var color2 = new Gray16(54321);
+
+            Assert.NotEqual(color1, color2);
+        }
+
         [Theory]
         [InlineData(0)]
         [InlineData(65535)]

tests/ImageSharp.Tests/PixelFormats/Gray8Tests.cs

@@ -1,10 +1,8 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-using System.Diagnostics;
 using System.Numerics;
 
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
 
@@ -45,6 +43,24 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
         public void Gray8_PackedValue_EqualsInput(byte input)
             => Assert.Equal(input, new Gray8(input).PackedValue);
 
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Gray8(100);
+            var color2 = new Gray8(100);
+            
+            Assert.Equal(color1, color2);
+        }
+
+        [Fact]
+        public void AreNotEqual()
+        {
+            var color1 = new Gray8(100);
+            var color2 = new Gray8(200);
+
+            Assert.NotEqual(color1, color2);
+        }
+
         [Fact]
         public void Gray8_FromScaledVector4()
         {

tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs

@@ -9,6 +9,36 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class NormalizedByte4Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new NormalizedByte4(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new NormalizedByte4(new Vector4(0.0f));
+            var color3 = new NormalizedByte4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+            var color4 = new NormalizedByte4(1.0f, 0.0f, 1.0f, 1.0f);
+
+            Assert.Equal(color1, color2);
+            Assert.Equal(color3, color4);
+        }
+
+        /// <summary>
+        /// Tests the equality operators for inequality.
+        /// </summary>
+        [Fact]
+        public void AreNotEqual()
+        {
+            var color1 = new NormalizedByte4(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new NormalizedByte4(new Vector4(1.0f));
+            var color3 = new NormalizedByte4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new NormalizedByte4(1.0f, 1.0f, 0.0f, 1.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
         [Fact]
         public void NormalizedByte4_PackedValues()
         {
@@ -61,6 +91,90 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void NormalizedByte4_FromArgb32()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromArgb32(new Argb32(255, 255, 255, 255));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedByte4_FromBgr24()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedByte4_FromGrey8()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedByte4_FromGrey16()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedByte4_FromRgb24()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedByte4_FromRgba32()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgba32(new Rgba32(255, 255, 255, 255));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
         [Fact]
         public void NormalizedByte4_FromBgra5551()
         {
@@ -74,5 +188,47 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, normalizedByte4.ToVector4());
         }
+
+        [Fact]
+        public void NormalizedByte4_FromRgb48()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedByte4_FromRgba64()
+        {
+            // arrange
+            var byte4 = default(NormalizedByte4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedByte4_ToRgba32()
+        {
+            // arrange
+            var byte4 = new NormalizedByte4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+            var expected = new Rgba32(Vector4.One);
+            var actual = default(Rgba32);
+
+            // act
+            byte4.ToRgba32(ref actual);
+
+            Assert.Equal(expected, actual);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs

@@ -9,6 +9,36 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class NormalizedShort4Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new NormalizedShort4(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new NormalizedShort4(new Vector4(0.0f));
+            var color3 = new NormalizedShort4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+            var color4 = new NormalizedShort4(1.0f, 0.0f, 1.0f, 1.0f);
+
+            Assert.Equal(color1, color2);
+            Assert.Equal(color3, color4);
+        }
+
+        /// <summary>
+        /// Tests the equality operators for inequality.
+        /// </summary>
+        [Fact]
+        public void AreNotEqual()
+        {
+            var color1 = new NormalizedShort4(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new NormalizedShort4(new Vector4(1.0f));
+            var color3 = new NormalizedShort4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new NormalizedShort4(1.0f, 1.0f, 0.0f, 1.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
         [Fact]
         public void NormalizedShort4_PackedValues()
         {
@@ -62,6 +92,132 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void NormalizedShort4_FromArgb32()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromArgb32(new Argb32(255, 255, 255, 255));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_FromBgr24()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_FromGrey8()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_FromGrey16()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_FromRgb24()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_FromRgba32()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgba32(new Rgba32(255, 255, 255, 255));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_FromRgb48()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_FromRgba64()
+        {
+            // arrange
+            var byte4 = default(NormalizedShort4);
+            Vector4 expected = Vector4.One;
+
+            // act
+            byte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, byte4.ToScaledVector4());
+        }
+
+        [Fact]
+        public void NormalizedShort4_ToRgba32()
+        {
+            // arrange
+            var byte4 = new NormalizedShort4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+            var expected = new Rgba32(Vector4.One);
+            var actual = default(Rgba32);
+
+            // act
+            byte4.ToRgba32(ref actual);
+
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void NormalizedShort4_FromBgra5551()
         {

tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs

@@ -122,6 +122,24 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expectedPackedValue, rgba.PackedValue);
         }
 
+        [Fact]
+        public void Rgba1010102_FromRgba32()
+        {
+            // arrange
+            var rgba1 = default(Rgba1010102);
+            var rgba2 = default(Rgba1010102);
+            uint expectedPackedValue1 = uint.MaxValue;
+            uint expectedPackedValue2 = 0xFFF003FF;
+
+            // act
+            rgba1.FromRgba32(new Rgba32(255, 255, 255, 255));
+            rgba2.FromRgba32(new Rgba32(255, 0, 255, 255));
+
+            // assert
+            Assert.Equal(expectedPackedValue1, rgba1.PackedValue);
+            Assert.Equal(expectedPackedValue2, rgba2.PackedValue);
+        }
+
         [Fact]
         public void Rgba1010102_FromBgr24()
         {

tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs

@@ -146,5 +146,47 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             // assert
             Assert.Equal(expected, actual);
         }
+
+        [Fact]
+        public void RgbaVector_FromBgra5551()
+        {
+            // arrange
+            var rgb = default(RgbaVector);
+            Vector4 expected = Vector4.One;
+
+            // act
+            rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, rgb.ToScaledVector4());
+        }
+
+        [Fact]
+        public void RgbaVector_FromGrey16()
+        {
+            // arrange
+            var rgba = default(RgbaVector);
+            Vector4 expected = Vector4.One;
+
+            // act
+            rgba.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, rgba.ToScaledVector4());
+        }
+
+        [Fact]
+        public void RgbaVector_FromGrey8()
+        {
+            // arrange
+            var rgba = default(RgbaVector);
+            Vector4 expected = Vector4.One;
+
+            // act
+            rgba.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, rgba.ToScaledVector4());
+        }
     }
 }