diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
index 3cb6d6180..3fb39dd7e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
@@ -853,6 +853,166 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal(argb, new Argb32(141, 90, 0, 255));
         }
 
+        [Fact]
+        public void NormalizedShort4_PackedValues()
+        {
+            Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue);
+            Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
+            Assert.Equal((ulong)0x0, new NormalizedShort4(Vector4.Zero).PackedValue);
+            Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new NormalizedShort4(Vector4.One).PackedValue);
+            Assert.Equal(0x8001800180018001, new NormalizedShort4(-Vector4.One).PackedValue);
+        }
+
+        [Fact]
+        public void NormalizedShort4_ToVector4()
+        {
+            // Test ToVector4
+            Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One).ToVector4()));
+            Assert.True(Equal(Vector4.Zero, new NormalizedShort4(Vector4.Zero).ToVector4()));
+            Assert.True(Equal(-Vector4.One, new NormalizedShort4(-Vector4.One).ToVector4()));
+            Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One * 1234.0f).ToVector4()));
+            Assert.True(Equal(-Vector4.One, new NormalizedShort4(Vector4.One * -1234.0f).ToVector4()));
+        }
+
+        [Fact]
+        public void NormalizedShort4_ToScaledVector4()
+        {
+            // arrange
+            var short4 = new NormalizedShort4(Vector4.One);
+
+            // act
+            Vector4 scaled = short4.ToScaledVector4();
+
+            // assert
+            Assert.Equal(1, scaled.X);
+            Assert.Equal(1, scaled.Y);
+            Assert.Equal(1, scaled.Z);
+            Assert.Equal(1, scaled.W);
+        }
+
+        [Fact]
+        public void NormalizedShort4_PackFromScaledVector4()
+        {
+            // arrange
+            var pixel = default(NormalizedShort4);
+            Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4();
+
+            // act 
+            pixel.PackFromScaledVector4(scaled);
+
+            // assert
+            var expectedPackedValue = (ulong)0x7FFF7FFF7FFF7FFF;
+            Assert.Equal(expectedPackedValue, pixel.PackedValue);
+        }
+
+        [Fact]
+        public void NormalizedShort4_ToRgb24()
+        {
+            // arrange
+            var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
+            var rgb24 = default(Rgb24);
+
+            // act
+            short4.ToRgb24(ref rgb24);
+
+            // assert
+            var expectedRgb24 = new Rgb24(141, 90, 192);
+            Assert.Equal(expectedRgb24, rgb24);
+        }
+
+        [Fact]
+        public void NormalizedShort4_ToRgba32()
+        {
+            // arrange
+            var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
+            var rgba32 = default(Rgba32);
+
+            // act
+            short4.ToRgba32(ref rgba32);
+
+            // assert
+            var expectedRgba32 = new Rgba32(141, 90, 192, 39);
+            Assert.Equal(expectedRgba32, rgba32);
+        }
+
+        [Fact]
+        public void NormalizedShort4_ToBgr24()
+        {
+            // arrange
+            var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
+            var bgr24 = default(Bgr24);
+
+            // act
+            short4.ToBgr24(ref bgr24);
+
+            // assert
+            var expectedBgr24 = new Bgr24(141, 90, 192);
+            Assert.Equal(expectedBgr24, bgr24);
+        }
+
+        [Fact]
+        public void NormalizedShort4_ToArgb32()
+        {
+            // arrange
+            var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
+            var argb32 = default(Argb32);
+
+            // act
+            short4.ToArgb32(ref argb32);
+
+            // assert
+            var expectedArgb32 = new Argb32(141, 90, 192, 39);
+            Assert.Equal(expectedArgb32, argb32);
+        }
+
+        [Fact]
+        public void NormalizedShort4_PackFromRgba32_ToRgba32()
+        {
+            // arrange
+            var rgba32 = default(Rgba32);
+            var short4 = default(NormalizedShort4);
+
+            // act 
+            short4.PackFromRgba32(new Rgba32(9, 115, 202, 127));
+            short4.ToRgba32(ref rgba32);
+
+            // assert
+            var expectedRgba32 = new Rgba32(9, 115, 202, 127);
+            Assert.Equal(rgba32, expectedRgba32);
+        }
+
+        [Fact]
+        public void NormalizedShort4_PackFromBgra32_ToRgba32()
+        {
+            // arrange
+            var bgra32 = default(Bgra32);
+            var short4 = default(NormalizedShort4);
+
+            // act 
+            short4.PackFromBgra32(new Bgra32(9, 115, 202, 127));
+            short4.ToBgra32(ref bgra32);
+
+            // assert
+            var expectedBgra32 = new Bgra32(9, 115, 202, 127);
+            Assert.Equal(bgra32, expectedBgra32);
+        }
+
+        [Fact]
+        public void NormalizedShort4_PackFromArgb32_ToRgba32()
+        {
+            // arrange
+            var argb32 = default(Argb32);
+            var short4 = default(NormalizedShort4);
+
+            // act 
+            short4.PackFromArgb32(new Argb32(9, 115, 202, 127));
+            short4.ToArgb32(ref argb32);
+
+            // assert
+            var expectedArgb32 = new Argb32(9, 115, 202, 127);
+            Assert.Equal(argb32, expectedArgb32);
+        }
+
         [Fact]
         public void NormalizedShort4()
         {
@@ -1273,7 +1433,7 @@ namespace SixLabors.ImageSharp.Tests.Colors
         }
 
         [Fact]
-        public void Short4_TestPackedValues()
+        public void Short4_PackedValues()
         {
             var shortValue1 = new Short4(11547, 12653, 29623, 193);
             var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f);