Merge pull request #903 from brianpopow/feature/incTestCovPixelFormats

Add additional 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

@@ -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 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             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>()
                 {

tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs

@@ -9,6 +9,36 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Bgra4444Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Bgra4444(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Bgra4444(new Vector4(0.0f));
+            var color3 = new Bgra4444(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+            var color4 = new Bgra4444(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 Bgra4444(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Bgra4444(new Vector4(1.0f));
+            var color3 = new Bgra4444(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new Bgra4444(1.0f, 1.0f, 0.0f, 1.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
         [Fact]
         public void Bgra4444_PackedValue()
         {
@@ -48,6 +78,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(1, actual.W);
         }
 
+        [Fact]
+        public void Bgra4444_ToRgba32()
+        {
+            // arrange
+            var bgra = new Bgra4444(Vector4.One);
+            var expected = new Rgba32(Vector4.One);
+            var actual = default(Rgba32);
+
+            // act
+            bgra.ToRgba32(ref actual);
+
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgra4444_FromScaledVector4()
         {
@@ -78,6 +122,122 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, bgra.PackedValue);
         }
 
+        [Fact]
+        public void Bgra4444_FromArgb32()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromArgb32(new Argb32(255, 255, 255, 255));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra4444_FromRgba32()
+        {
+            // arrange
+            var bgra1 = default(Bgra4444);
+            var bgra2 = default(Bgra4444);
+            ushort expectedPackedValue1 = ushort.MaxValue;
+            ushort expectedPackedValue2 = 0xFF0F;
+
+            // act
+            bgra1.FromRgba32(new Rgba32(255, 255, 255, 255));
+            bgra2.FromRgba32(new Rgba32(255, 0, 255, 255));
+
+            // assert
+            Assert.Equal(expectedPackedValue1, bgra1.PackedValue);
+            Assert.Equal(expectedPackedValue2, bgra2.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra4444_FromRgb48()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra4444_FromRgba64()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra4444_FromGrey16()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra4444_FromGrey8()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra4444_FromBgr24()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
+        [Fact]
+        public void Bgra4444_FromRgb24()
+        {
+            // arrange
+            var bgra = default(Bgra4444);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
         [Fact]
         public void Bgra4444_Clamping()
         {

tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.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;
@@ -10,6 +9,36 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Bgra5551Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Bgra5551(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Bgra5551(new Vector4(0.0f));
+            var color3 = new Bgra5551(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new Bgra5551(1.0f, 0.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 Bgra5551(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Bgra5551(new Vector4(1.0f));
+            var color3 = new Bgra5551(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new Bgra5551(1.0f, 1.0f, 0.0f, 1.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
         [Fact]
         public void Bgra5551_PackedValue()
         {
@@ -54,6 +83,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(1, actual.W);
         }
 
+        [Fact]
+        public void Bgra5551_ToRgba32()
+        {
+            // arrange
+            var bgra = new Bgra5551(Vector4.One);
+            var expected = new Rgba32(Vector4.One);
+            var actual = default(Rgba32);
+
+            // act
+            bgra.ToRgba32(ref actual);
+
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgra5551_FromScaledVector4()
         {
@@ -70,6 +113,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Bgra5551_FromBgra5551()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            var actual = default(Bgra5551);
+            var expected = new Bgra5551(1.0f, 0.0f, 1.0f, 1.0f);
+
+            // act 
+            bgra.FromBgra5551(expected);
+            actual.FromBgra5551(bgra);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgra5551_FromRgba32()
         {
@@ -120,6 +179,20 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expectedPackedValue, bgra.PackedValue);
         }
 
+        [Fact]
+        public void Bgra5551_FromRgb48()
+        {
+            // arrange
+            var bgra = default(Bgra5551);
+            ushort expectedPackedValue = ushort.MaxValue;
+
+            // act
+            bgra.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        }
+
         [Fact]
         public void Bgra5551_FromRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs

@@ -9,6 +9,36 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Byte4Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Byte4(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Byte4(new Vector4(0.0f));
+            var color3 = new Byte4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+            var color4 = new Byte4(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 Byte4(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Byte4(new Vector4(1.0f));
+            var color3 = new Byte4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new Byte4(1.0f, 1.0f, 0.0f, 1.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
         [Fact]
         public void Byte4_PackedValue()
         {
@@ -45,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()
         {
@@ -61,18 +105,130 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Byte4_FromArgb32()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            byte4.FromArgb32(new Argb32(255, 255, 255, 255));
+
+            // assert
+            Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        }
+
+        [Fact]
+        public void Byte4_FromBgr24()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            byte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        }
+
+        [Fact]
+        public void Byte4_FromGrey8()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            byte4.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        }
+
+        [Fact]
+        public void Byte4_FromGrey16()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            byte4.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        }
+
+        [Fact]
+        public void Byte4_FromRgb24()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            byte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        }
+
         [Fact]
         public void Byte4_FromBgra5551()
         {
             // arrange
-            var rgb = default(Byte4);
+            var byte4 = default(Byte4);
             uint expected = 0xFFFFFFFF;
 
             // act
-            rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+            byte4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+
+            // assert
+            Assert.Equal(expected, byte4.PackedValue);
+        }
+
+        [Fact]
+        public void Byte4_FromRgba32()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue1 = uint.MaxValue;
+            
+            // act
+            byte4.FromRgba32(new Rgba32(255, 255, 255, 255));
+            
+            // assert
+            Assert.Equal(expectedPackedValue1, byte4.PackedValue);
+        }
+
+        [Fact]
+        public void Byte4_FromRgb48()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            byte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        }
+
+        [Fact]
+        public void Byte4_FromRgba64()
+        {
+            // arrange
+            var byte4 = default(Byte4);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            byte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
             // assert
-            Assert.Equal(expected, rgb.PackedValue);
+            Assert.Equal(expectedPackedValue, byte4.PackedValue);
         }
 
         [Fact]

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

@@ -9,6 +9,36 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 {
     public class Rgba1010102Tests
     {
+        /// <summary>
+        /// Tests the equality operators for equality.
+        /// </summary>
+        [Fact]
+        public void AreEqual()
+        {
+            var color1 = new Rgba1010102(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Rgba1010102(new Vector4(0.0f));
+            var color3 = new Rgba1010102(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+            var color4 = new Rgba1010102(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 Rgba1010102(0.0f, 0.0f, 0.0f, 0.0f);
+            var color2 = new Rgba1010102(new Vector4(1.0f));
+            var color3 = new Rgba1010102(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+            var color4 = new Rgba1010102(1.0f, 1.0f, 0.0f, 1.0f);
+
+            Assert.NotEqual(color1, color2);
+            Assert.NotEqual(color3, color4);
+        }
+
         [Fact]
         public void Rgba1010102_PackedValue()
         {
@@ -78,6 +108,122 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, rgba.PackedValue);
         }
 
+        [Fact]
+        public void Rgba1010102_FromArgb32()
+        {
+            // arrange
+            var rgba = default(Rgba1010102);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            rgba.FromArgb32(new Argb32(255, 255, 255, 255));
+
+            // assert
+            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()
+        {
+            // arrange
+            var rgba = default(Rgba1010102);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            rgba.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, rgba.PackedValue);
+        }
+
+        [Fact]
+        public void Rgba1010102_FromGrey8()
+        {
+            // arrange
+            var rgba = default(Rgba1010102);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            rgba.FromGray8(new Gray8(byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, rgba.PackedValue);
+        }
+
+        [Fact]
+        public void Rgba1010102_FromGrey16()
+        {
+            // arrange
+            var rgba = default(Rgba1010102);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            rgba.FromGray16(new Gray16(ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, rgba.PackedValue);
+        }
+
+        [Fact]
+        public void Rgba1010102_FromRgb24()
+        {
+            // arrange
+            var rgba = default(Rgba1010102);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            rgba.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, rgba.PackedValue);
+        }
+
+        [Fact]
+        public void Rgba1010102_FromRgb48()
+        {
+            // arrange
+            var rgba = default(Rgba1010102);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            rgba.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, rgba.PackedValue);
+        }
+
+        [Fact]
+        public void Rgba1010102_FromRgba64()
+        {
+            // arrange
+            var rgba = default(Rgba1010102);
+            uint expectedPackedValue = uint.MaxValue;
+
+            // act
+            rgba.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+
+            // assert
+            Assert.Equal(expectedPackedValue, rgba.PackedValue);
+        }
+
         [Fact]
         public void Rgba1010102_Clamping()
         {

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