Add Rgb48 tests

tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs

@@ -175,6 +175,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Alpha8_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var alpha = default(Alpha8);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(0, 0, 0);
+
+            // act
+            alpha.PackFromRgb48(expected);
+            alpha.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Alpha8_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs

@@ -190,6 +190,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Argb32_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var argb = default(Argb32);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            argb.PackFromRgb48(expected);
+            argb.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Argb32_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs

@@ -140,6 +140,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(new Bgra32(1, 2, 3, 255), bgra);
         }
 
+        [Fact]
+        public void Bgr24_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Bgr24);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgr24_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs

@@ -145,6 +145,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Bgr565_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Bgr565);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgr565_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs

@@ -147,6 +147,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(new Bgra32(1, 2, 3, 4), bgra);
         }
 
+        [Fact]
+        public void Bgra32_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Bgra32);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgra32_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs

@@ -194,6 +194,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Bgra4444_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Bgra4444);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgra4444_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs

@@ -193,6 +193,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Bgra5551_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Bgra5551);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Bgra5551_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs

@@ -191,6 +191,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Byte4_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Byte4);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Byte4_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs

@@ -142,6 +142,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void HalfSingle_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(HalfSingle);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void HalfSingle_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs

@@ -147,6 +147,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void HalfVector2_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(HalfVector2);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 65535, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void HalfVector2_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs

@@ -189,6 +189,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void HalfVector4_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(HalfVector4);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void HalfVector4_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs

@@ -158,6 +158,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void NormalizedByte2_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(NormalizedByte2);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 65535, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void NormalizedByte2_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs

@@ -169,6 +169,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void NormalizedByte4_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(NormalizedByte4);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 65535, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void NormalizedByte4_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs

@@ -162,6 +162,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void NormalizedShort2_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(NormalizedShort2);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 65535, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void NormalizedShort2_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs

@@ -170,6 +170,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void NormalizedShort4_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(NormalizedShort4);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 65535, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void NormalizedShort4_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs

@@ -129,6 +129,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Rg32_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Rg32);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 65535, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Rg32_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs

@@ -140,6 +140,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(new Bgra32(1, 2, 3, 255), bgra);
         }
 
+        [Fact]
+        public void Rgb24_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Rgb24);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Rgb24_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs

@@ -149,6 +149,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Rgb48_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Rgb48);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Rgb48_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs

@@ -179,6 +179,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Rgba1010102_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Rgba1010102);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Rgba1010102_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs

@@ -306,6 +306,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Rgba32_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Rgba32);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Rgba32_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs

@@ -151,6 +151,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Rgb48_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Rgb48);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Rgba64_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs

@@ -127,6 +127,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(4, ordered[3]);
         }
 
+        [Fact]
+        public void RgbaVector_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(RgbaVector);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void RgbaVector_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs

@@ -170,6 +170,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Short2_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Short2);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 65535, 0);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Short2_PackFromRgba64_ToRgba64()
         {

tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs

@@ -206,6 +206,22 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Short4_PackFromRgb48_ToRgb48()
+        {
+            // arrange
+            var input = default(Short4);
+            var actual = default(Rgb48);
+            var expected = new Rgb48(65535, 0, 65535);
+
+            // act
+            input.PackFromRgb48(expected);
+            input.ToRgb48(ref actual);
+
+            // assert
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Short4_PackFromRgba64_ToRgba64()
         {