Add additional pixel conversion tests

src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs

@@ -149,7 +149,7 @@ public void ToRgba32(ref Rgba32 dest)
         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

@@ -9,6 +9,36 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Bgr565Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Bgr565(0.0f, 0.0f, 0.0f);
+            var color2 = new Bgr565(new Vector3(0.0f));
+            var color3 = new Bgr565(new Vector3(1.0f, 0.0f, 1.0f));
+            var color4 = new Bgr565(1.0f, 0.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 Bgr565(0.0f, 0.0f, 0.0f);
+            var color2 = new Bgr565(new Vector3(1.0f));
+            var color3 = new Bgr565(new Vector3(1.0f, 0.0f, 0.0f));
+            var color4 = new Bgr565(1.0f, 1.0f, 0.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
         [Fact]
         public void Bgr565_PackedValue()
         {
@@ -77,6 +107,140 @@ public void Bgr565_FromBgra5551()
             Assert.Equal(expected, bgr.PackedValue);
         }
 
+        [Fact]
+        public void Bgr565_FromArgb32()
+        {
+            // arrange
+            var bgr1 = default(Bgr565);
+            var bgr2 = default(Bgr565);
+            ushort expected1 = ushort.MaxValue;
+            ushort expected2 = ushort.MaxValue;
+
+            // act
+            bgr1.FromArgb32(new Argb32(1.0f, 1.0f, 1.0f, 1.0f));
+            bgr2.FromArgb32(new Argb32(1.0f, 1.0f, 1.0f, 0.0f));
+
+            // assert
+            Assert.Equal(expected1, bgr1.PackedValue);
+            Assert.Equal(expected2, bgr2.PackedValue);
+        }
+
+        [Fact]
+        public void Bgr565_FromRgba32()
+        {
+            // arrange
+            var bgr1 = default(Bgr565);
+            var bgr2 = default(Bgr565);
+            ushort expected1 = ushort.MaxValue;
+            ushort expected2 = ushort.MaxValue;
+
+            // act
+            bgr1.FromRgba32(new Rgba32(1.0f, 1.0f, 1.0f, 1.0f));
+            bgr2.FromRgba32(new Rgba32(1.0f, 1.0f, 1.0f, 0.0f));
+
+            // assert
+            Assert.Equal(expected1, bgr1.PackedValue);
+            Assert.Equal(expected2, bgr2.PackedValue);
+        }
+
+        [Fact]
+        public void Bgr565_ToRgba32()
+        {
+            // arrange
+            var bgra = new Bgr565(Vector3.One);
+            var expected = new Rgba32(Vector4.One);
+            var actual = default(Rgba32);
+
+            // act
+            bgra.ToRgba32(ref actual);
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Bgra565_FromRgb48()
+        {
+            // arrange
+            var bgr = default(Bgr565);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgr.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgr.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra565_FromRgba64()
+        {
+            // arrange
+            var bgr = default(Bgr565);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgr.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgr.PackedValue);
+        }
+
+        [Fact]
+        public void Bgr565_FromBgr24()
+        {
+            // arrange
+            var bgr = default(Bgr565);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            bgr.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, bgr.PackedValue);
+        }
+
+        [Fact]
+        public void Bgr565_FromRgb24()
+        {
+            // arrange
+            var bgr = default(Bgr565);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            bgr.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, bgr.PackedValue);
+        }
+
+        [Fact]
+        public void Bgr565_FromGrey8()
+        {
+            // arrange
+            var bgr = default(Bgr565);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            bgr.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expected, bgr.PackedValue);
+        }
+
+        [Fact]
+        public void Bgr565_FromGrey16()
+        {
+            // arrange
+            var bgr = default(Bgr565);
+            ushort expected = ushort.MaxValue;
+
+            // act
+            bgr.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expected, bgr.PackedValue);
+        }
+
         [Fact]
         public void Bgr565_Clamping()
         {

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>()
                 {