diff --git a/HPPH.Test/ConvertTests.cs b/HPPH.Test/ConvertTests.cs
index b05e767..1dfd759 100644
--- a/HPPH.Test/ConvertTests.cs
+++ b/HPPH.Test/ConvertTests.cs
@@ -10,24 +10,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGB> referenceData = data;
-
-            Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorBGR> result = PixelHelper.Convert<ColorRGB, ColorBGR>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGB reference = referenceData[i];
-                ColorBGR test = result[i];
+                ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGB> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorBGR> result = PixelHelper.Convert<ColorRGB, ColorBGR>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGB reference = referenceData[i];
+                    ColorBGR test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -37,24 +40,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGBA> referenceData = data;
-
-            Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorARGB> result = PixelHelper.Convert<ColorRGBA, ColorARGB>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGBA reference = referenceData[i];
-                ColorARGB test = result[i];
+                ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGBA> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorARGB> result = PixelHelper.Convert<ColorRGBA, ColorARGB>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGBA reference = referenceData[i];
+                    ColorARGB test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -64,24 +70,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGBA> referenceData = data;
-
-            Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorBGRA> result = PixelHelper.Convert<ColorRGBA, ColorBGRA>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGBA reference = referenceData[i];
-                ColorBGRA test = result[i];
+                ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGBA> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorBGRA> result = PixelHelper.Convert<ColorRGBA, ColorBGRA>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGBA reference = referenceData[i];
+                    ColorBGRA test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -91,24 +100,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGBA> referenceData = data;
-
-            Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorRGB> result = PixelHelper.Convert<ColorRGBA, ColorRGB>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGBA reference = referenceData[i];
-                ColorRGB test = result[i];
+                ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGBA> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorRGB> result = PixelHelper.Convert<ColorRGBA, ColorRGB>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGBA reference = referenceData[i];
+                    ColorRGB test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -118,24 +130,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGBA> referenceData = data;
-
-            Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorBGR> result = PixelHelper.Convert<ColorRGBA, ColorBGR>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGBA reference = referenceData[i];
-                ColorBGR test = result[i];
+                ColorRGBA[] data = ImageHelper.Get4ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGBA> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGBA> sourceData = new ColorRGBA[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorBGR> result = PixelHelper.Convert<ColorRGBA, ColorBGR>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGBA reference = referenceData[i];
+                    ColorBGR test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -145,24 +160,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGB> referenceData = data;
-
-            Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorRGBA> result = PixelHelper.Convert<ColorRGB, ColorRGBA>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGB reference = referenceData[i];
-                ColorRGBA test = result[i];
+                ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGB> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorRGBA> result = PixelHelper.Convert<ColorRGB, ColorRGBA>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGB reference = referenceData[i];
+                    ColorRGBA test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -172,24 +190,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGB> referenceData = data;
-
-            Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorARGB> result = PixelHelper.Convert<ColorRGB, ColorARGB>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGB reference = referenceData[i];
-                ColorARGB test = result[i];
+                ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGB> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorARGB> result = PixelHelper.Convert<ColorRGB, ColorARGB>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGB reference = referenceData[i];
+                    ColorARGB test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -199,24 +220,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image);
-            ReadOnlySpan<ColorRGB> referenceData = data;
-
-            Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorBGRA> result = PixelHelper.Convert<ColorRGB, ColorBGRA>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGB reference = referenceData[i];
-                ColorBGRA test = result[i];
+                ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGB> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorBGRA> result = PixelHelper.Convert<ColorRGB, ColorBGRA>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGB reference = referenceData[i];
+                    ColorBGRA test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }
@@ -226,24 +250,27 @@ public class ConvertTests
     {
         foreach (string image in GetTestImages())
         {
-            ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image).SkipLast(1).ToArray();
-            ReadOnlySpan<ColorRGB> referenceData = data;
-
-            Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
-            referenceData.CopyTo(sourceData);
-
-            Span<ColorABGR> result = PixelHelper.Convert<ColorRGB, ColorABGR>(sourceData);
-
-            Assert.AreEqual(referenceData.Length, result.Length);
-            for (int i = 0; i < referenceData.Length; i++)
+            for (int skip = 0; skip < 4; skip++)
             {
-                ColorRGB reference = referenceData[i];
-                ColorABGR test = result[i];
+                ColorRGB[] data = ImageHelper.Get3ByteColorsFromImage(image).SkipLast(skip).ToArray();
+                ReadOnlySpan<ColorRGB> referenceData = data;
 
-                Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
-                Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
-                Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
-                Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                Span<ColorRGB> sourceData = new ColorRGB[referenceData.Length];
+                referenceData.CopyTo(sourceData);
+
+                Span<ColorABGR> result = PixelHelper.Convert<ColorRGB, ColorABGR>(sourceData);
+
+                Assert.AreEqual(referenceData.Length, result.Length);
+                for (int i = 0; i < referenceData.Length; i++)
+                {
+                    ColorRGB reference = referenceData[i];
+                    ColorABGR test = result[i];
+
+                    Assert.AreEqual(reference.R, test.R, $"R differs at index {i}");
+                    Assert.AreEqual(reference.G, test.G, $"G differs at index {i}");
+                    Assert.AreEqual(reference.B, test.B, $"B differs at index {i}");
+                    Assert.AreEqual(reference.A, test.A, $"A differs at index {i}");
+                }
             }
         }
     }