From 65ff9db024ccce3c1d9716a041cf97ad8367fe8e Mon Sep 17 00:00:00 2001 From: popow Date: Sat, 26 May 2018 18:23:13 +0200 Subject: [PATCH 01/17] refactored short4 tests, so the different tests are better isolated (#594) --- .../PixelFormats/PackedPixelTests.cs | 201 ++++++++++++++++-- 1 file changed, 181 insertions(+), 20 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index f90b592de..256fa9589 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -1148,15 +1148,6 @@ namespace SixLabors.ImageSharp.Tests.Colors [Fact] public void Rgba64() { - if (!TestEnvironment.Is64BitProcess) - { - // Can't decide if these assertions are robust enough to be portable across CPU architectures. - // Let's just skip it for 32 bits! - // TODO: Someone should review this! - // see https://github.com/SixLabors/ImageSharp/issues/594 - return; - } - // Test the limits. Assert.Equal((ulong)0x0, new Rgba64(Vector4.Zero).PackedValue); Assert.Equal(0xFFFFFFFFFFFFFFFF, new Rgba64(Vector4.One).PackedValue); @@ -1282,17 +1273,187 @@ namespace SixLabors.ImageSharp.Tests.Colors } [Fact] - public void Short4() + public void Short4_TestLimits() { - if (TestEnvironment.IsLinux) - { - // Can't decide if these assertions are robust enough to be portable across CPU architectures. - // Let's just skip it for 32 bits! - // TODO: Someone should review this! - // see https://github.com/SixLabors/ImageSharp/issues/594 - return; - } + // Test the limits. + Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); + Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); + Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); + } + + [Fact] + public void Short4_ToVector4() + { + // Test ToVector4. + Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4()); + Assert.Equal(Vector4.UnitX * 0x7FFF, new Short4(Vector4.UnitX * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitY * 0x7FFF, new Short4(Vector4.UnitY * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitZ * 0x7FFF, new Short4(Vector4.UnitZ * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitW * 0x7FFF, new Short4(Vector4.UnitW * 0x7FFF).ToVector4()); + } + + [Fact] + public void Short4_ToScaledVector4() + { + // Test ToScaledVector4. + // arrange + var short4 = new Short4(Vector4.One * 0x7FFF); + + // 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 Short4_PackFromScaledVector4() + { + // Test PackFromScaledVector4. + // arrange + var short4 = new Short4(Vector4.One * 0x7FFF); + Vector4 scaled = short4.ToScaledVector4(); + + // act + var pixel = default(Short4); + pixel.PackFromScaledVector4(scaled); + + // assert + long expectedPackedValue = 0x7FFF7FFF7FFF7FFF; + Assert.Equal((ulong)expectedPackedValue, pixel.PackedValue); + } + + [Fact] + public void Short4_Clamping() + { + // Test clamping. + Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 1234567.0f).ToVector4()); + Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -1234567.0f).ToVector4()); + } + + [Fact] + public void Short4_ToRgb24() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var rgb24 = default(Rgb24); + + // act + shortValue.ToRgb24(ref rgb24); + // assert + var expectedRgb24 = new Rgb24(172, 177, 243); + Assert.Equal(rgb24, expectedRgb24); + } + + [Fact] + public void Short4_ToBgr24() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var bgr24 = default(Bgr24); + + // act + shortValue.ToBgr24(ref bgr24); + + // assert + var expectedBgr24 = new Bgr24(172, 177, 243); + Assert.Equal(bgr24, expectedBgr24); + } + + [Fact] + public void Short4_ToRgba32() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var rgba32 = default(Rgba32); + + // act + shortValue.ToRgba32(ref rgba32); + + // assert + var expectedRgba32 = new Rgba32(172, 177, 243, 128); + Assert.Equal(rgba32, expectedRgba32); + } + + [Fact] + public void Short4_ToBgra32() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var bgra32 = default(Bgra32); + + // act + shortValue.ToBgra32(ref bgra32); + + // assert + var expectedBgra32 = new Bgra32(172, 177, 243, 128); + Assert.Equal(bgra32, expectedBgra32); + } + + [Fact] + public void Short4_ToArgb32() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var argb32 = default(Argb32); + + // act + shortValue.ToArgb32(ref argb32); + + // assert + var expectedArgb32 = new Argb32(172, 177, 243, 128); + Assert.Equal(argb32, expectedArgb32); + } + + [Fact] + public void Short4_Ordering() + { + // arrange + float x = 0.1f; + float y = -0.3f; + float z = 0.5f; + float w = -0.7f; + var shortValue1 = new Short4(x, y, z, w); + + // act + var shortValue1Packed = shortValue1.PackedValue; + Assert.Equal(18446462598732840960, shortValue1.PackedValue); + + x = 11547; + y = 12653; + z = 29623; + w = 193; + Assert.Equal((ulong)0x00c173b7316d2d1b, new Short4(x, y, z, w).PackedValue); + + var rgba = default(Rgba32); + var bgra = default(Bgra32); + var argb = default(Argb32); + + var r = default(Short4); + r.PackFromRgba32(new Rgba32(20, 38, 0, 255)); + r.ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(20, 38, 0, 255)); + + r = default(Short4); + r.PackFromBgra32(new Bgra32(20, 38, 0, 255)); + r.ToBgra32(ref bgra); + Assert.Equal(bgra, new Bgra32(20, 38, 0, 255)); + + r = default(Short4); + r.PackFromArgb32(new Argb32(20, 38, 0, 255)); + r.ToArgb32(ref argb); + Assert.Equal(argb, new Argb32(20, 38, 0, 255)); + } + + [Fact] + public void Short4() + { // Test the limits. Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); @@ -1343,8 +1504,8 @@ namespace SixLabors.ImageSharp.Tests.Colors var argb = default(Argb32); new Short4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(172, 177, 243)); - + Assert.Equal(rgb, new Rgb24(172, 177, 243)); // this seems to be causing the problem #594 + new Short4(x, y, z, w).ToRgba32(ref rgba); Assert.Equal(rgba, new Rgba32(172, 177, 243, 128)); From a90825f2f58bd45f8a06f9f025f9030378b95c36 Mon Sep 17 00:00:00 2001 From: popow Date: Sat, 26 May 2018 18:37:55 +0200 Subject: [PATCH 02/17] fixed expected and actual order in the Asserts --- .../PixelFormats/PackedPixelTests.cs | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 256fa9589..199409e0e 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -1332,8 +1332,17 @@ namespace SixLabors.ImageSharp.Tests.Colors public void Short4_Clamping() { // Test clamping. - Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 1234567.0f).ToVector4()); - Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -1234567.0f).ToVector4()); + // arrange + var short1 = new Short4(Vector4.One * 1234567.0f); + var short2 = new Short4(Vector4.One * -1234567.0f); + + // act + var vector1 = short1.ToVector4(); + var vector2 = short2.ToVector4(); + + // assert + Assert.Equal(Vector4.One * 0x7FFF, vector1); + Assert.Equal(Vector4.One * -0x8000, vector2); } [Fact] @@ -1348,7 +1357,7 @@ namespace SixLabors.ImageSharp.Tests.Colors // assert var expectedRgb24 = new Rgb24(172, 177, 243); - Assert.Equal(rgb24, expectedRgb24); + Assert.Equal(expectedRgb24, rgb24); } [Fact] @@ -1363,7 +1372,7 @@ namespace SixLabors.ImageSharp.Tests.Colors // assert var expectedBgr24 = new Bgr24(172, 177, 243); - Assert.Equal(bgr24, expectedBgr24); + Assert.Equal(expectedBgr24, bgr24); } [Fact] @@ -1378,7 +1387,7 @@ namespace SixLabors.ImageSharp.Tests.Colors // assert var expectedRgba32 = new Rgba32(172, 177, 243, 128); - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expectedRgba32, rgba32); } [Fact] @@ -1393,7 +1402,7 @@ namespace SixLabors.ImageSharp.Tests.Colors // assert var expectedBgra32 = new Bgra32(172, 177, 243, 128); - Assert.Equal(bgra32, expectedBgra32); + Assert.Equal(expectedBgra32, bgra32); } [Fact] @@ -1408,7 +1417,7 @@ namespace SixLabors.ImageSharp.Tests.Colors // assert var expectedArgb32 = new Argb32(172, 177, 243, 128); - Assert.Equal(argb32, expectedArgb32); + Assert.Equal(expectedArgb32, argb32); } [Fact] From 8a42586a5eadcb27f7486cda95ec43d636b10a11 Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 27 May 2018 13:55:13 +0200 Subject: [PATCH 03/17] skipping short4 test on linux again --- tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 199409e0e..40f9644e3 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -1463,6 +1463,15 @@ namespace SixLabors.ImageSharp.Tests.Colors [Fact] public void Short4() { + if (TestEnvironment.IsLinux) + { + // Can't decide if these assertions are robust enough to be portable across CPU architectures. + // Let's just skip it for 32 bits! + // TODO: Someone should review this! + // see https://github.com/SixLabors/ImageSharp/issues/594 + return; + } + // Test the limits. Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); From 4df8b217e7730c1dac8f38f8e40cfe855b5ff5b0 Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 27 May 2018 14:52:47 +0200 Subject: [PATCH 04/17] even more refactoring of short4 tests --- .../PixelFormats/PackedPixelTests.cs | 78 +++++++++++-------- 1 file changed, 46 insertions(+), 32 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 40f9644e3..3cb6d6180 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -1273,9 +1273,15 @@ namespace SixLabors.ImageSharp.Tests.Colors } [Fact] - public void Short4_TestLimits() + public void Short4_TestPackedValues() { - // Test the limits. + var shortValue1 = new Short4(11547, 12653, 29623, 193); + var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f); + + ulong expectedPackedValue1 = 0x00c173b7316d2d1b; + ulong expectedPackedValue2 = 18446462598732840960; + Assert.Equal(expectedPackedValue1, shortValue1.PackedValue); + Assert.Equal(expectedPackedValue2, shortValue2.PackedValue); Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); @@ -1417,47 +1423,55 @@ namespace SixLabors.ImageSharp.Tests.Colors // assert var expectedArgb32 = new Argb32(172, 177, 243, 128); - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expectedArgb32, argb32); } [Fact] - public void Short4_Ordering() + public void Short4_PackFromRgba32_ToRgba32() { // arrange - float x = 0.1f; - float y = -0.3f; - float z = 0.5f; - float w = -0.7f; - var shortValue1 = new Short4(x, y, z, w); + var rgba32 = default(Rgba32); + var short4 = default(Short4); - // act - var shortValue1Packed = shortValue1.PackedValue; - Assert.Equal(18446462598732840960, shortValue1.PackedValue); + // act + short4.PackFromRgba32(new Rgba32(20, 38, 0, 255)); + short4.ToRgba32(ref rgba32); - x = 11547; - y = 12653; - z = 29623; - w = 193; - Assert.Equal((ulong)0x00c173b7316d2d1b, new Short4(x, y, z, w).PackedValue); + // assert + var expectedRgba32 = new Rgba32(20, 38, 0, 255); + Assert.Equal(rgba32, expectedRgba32); + } - var rgba = default(Rgba32); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void Short4_PackFromBgra32_ToRgba32() + { + // arrange + var bgra32 = default(Bgra32); + var short4 = default(Short4); - var r = default(Short4); - r.PackFromRgba32(new Rgba32(20, 38, 0, 255)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 0, 255)); + // act + short4.PackFromBgra32(new Bgra32(20, 38, 0, 255)); + short4.ToBgra32(ref bgra32); - r = default(Short4); - r.PackFromBgra32(new Bgra32(20, 38, 0, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 0, 255)); + // assert + var expectedBgra32 = new Bgra32(20, 38, 0, 255); + Assert.Equal(bgra32, expectedBgra32); + } - r = default(Short4); - r.PackFromArgb32(new Argb32(20, 38, 0, 255)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(20, 38, 0, 255)); + [Fact] + public void Short4_PackFromArgb32_ToRgba32() + { + // arrange + var argb32 = default(Argb32); + var short4 = default(Short4); + + // act + short4.PackFromArgb32(new Argb32(20, 38, 0, 255)); + short4.ToArgb32(ref argb32); + + // assert + var expectedArgb32 = new Argb32(20, 38, 0, 255); + Assert.Equal(argb32, expectedArgb32); } [Fact] From 348fe0c433fdba0c6c031225e7f4eab8677b9745 Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 27 May 2018 18:58:51 +0200 Subject: [PATCH 05/17] refactored NormalizedShort4 tests (#594) --- .../PixelFormats/PackedPixelTests.cs | 162 +++++++++++++++++- 1 file changed, 161 insertions(+), 1 deletion(-) 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); From 4254cad2b84894f6d10413f2ddd84b26ddde5d94 Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 27 May 2018 19:33:07 +0200 Subject: [PATCH 06/17] refactored NormalizedByte4 tests #594 --- .../PixelFormats/PackedPixelTests.cs | 160 ++++++++++++++++++ 1 file changed, 160 insertions(+) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 3fb39dd7e..77bfe6675 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -697,6 +697,166 @@ namespace SixLabors.ImageSharp.Tests.Colors Assert.Equal(argb, new Argb32(141, 90, 0, 255)); } + [Fact] + public void NormalizedByte4_PackedValues() + { + Assert.Equal(0xA740DA0D, new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); + Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); + Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); + Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); + } + + [Fact] + public void NormalizedByte4_ToVector4() + { + // Test ToVector4 + Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4())); + Assert.True(Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4())); + Assert.True(Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4())); + } + + [Fact] + public void NormalizedByte4_ToScaledVector4() + { + // arrange + var short4 = new NormalizedByte4(-Vector4.One); + + // act + Vector4 scaled = short4.ToScaledVector4(); + + // assert + Assert.Equal(0, scaled.X); + Assert.Equal(0, scaled.Y); + Assert.Equal(0, scaled.Z); + Assert.Equal(0, scaled.W); + } + + [Fact] + public void NormalizedByte4_PackFromScaledVector4() + { + // arrange + var pixel = default(NormalizedByte4); + Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); + + // act + pixel.PackFromScaledVector4(scaled); + + // assert + var expectedPackedValue = 0x81818181; + Assert.Equal(expectedPackedValue, pixel.PackedValue); + } + + [Fact] + public void NormalizedByte4_ToRgb24() + { + // arrange + var short4 = new NormalizedByte4(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 NormalizedByte4_ToRgba32() + { + // arrange + var short4 = new NormalizedByte4(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 NormalizedByte4_ToBgr24() + { + // arrange + var short4 = new NormalizedByte4(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 NormalizedByte4_ToArgb32() + { + // arrange + var short4 = new NormalizedByte4(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 NormalizedByte4_PackFromRgba32_ToRgba32() + { + // arrange + var rgba32 = default(Rgba32); + var short4 = default(NormalizedByte4); + + // 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 NormalizedByte4_PackFromBgra32_ToRgba32() + { + // arrange + var bgra32 = default(Bgra32); + var short4 = default(NormalizedByte4); + + // 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 NormalizedByte4_PackFromArgb32_ToRgba32() + { + // arrange + var argb32 = default(Argb32); + var short4 = default(NormalizedByte4); + + // 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 NormalizedByte4() { From b63b99bbcbb93e94b800f4a393d97e5e8443d6f7 Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 27 May 2018 19:48:42 +0200 Subject: [PATCH 07/17] moved NormalizedByte4, NormalizedShort4, Short4 test to a separate file to be able to reproduce #594. Note: the refactored better isolated tests do not produce the error --- .../PixelFormats/PackedPixelTests.cs | 267 +----------------- 1 file changed, 2 insertions(+), 265 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 77bfe6675..7e9d5dffa 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -857,96 +857,6 @@ namespace SixLabors.ImageSharp.Tests.Colors Assert.Equal(argb32, expectedArgb32); } - [Fact] - public void NormalizedByte4() - { - if (TestEnvironment.IsLinux) - { - // Can't decide if these assertions are robust enough to be portable across CPU architectures. - // Let's just skip it for 32 bits! - // TODO: Someone should review this! - // see https://github.com/SixLabors/ImageSharp/issues/594 - return; - } - - // Test PackedValue - Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); - Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); - Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(0, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(NormalizedByte4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0x81818181, pixel.PackedValue); - - // Test Ordering - float x = 0.1f; - float y = -0.3f; - float z = 0.5f; - float w = -0.7f; - Assert.Equal(0xA740DA0D, new NormalizedByte4(x, y, z, w).PackedValue); - var n = default(NormalizedByte4); - n.PackFromRgba32(new Rgba32(141, 90, 192, 39)); - Assert.Equal(0xA740DA0D, n.PackedValue); - - Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new NormalizedByte4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 192)); - - new NormalizedByte4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); - - new NormalizedByte4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(141, 90, 192)); - - new NormalizedByte4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 192, 39)); - - new NormalizedByte4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 192, 39)); - - // http://community.monogame.net/t/normalizedbyte4-texture2d-gives-different-results-from-xna/8012/8 - var r = default(NormalizedByte4); - r.PackFromRgba32(new Rgba32(9, 115, 202, 127)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(9, 115, 202, 127)); - - r.PackedValue = 0xff4af389; - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(9, 115, 202, 127)); - - r = default(NormalizedByte4); - r.PackFromArgb32(new Argb32(9, 115, 202, 127)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(9, 115, 202, 127)); - - r = default(NormalizedByte4); - r.PackFromBgra32(new Bgra32(9, 115, 202, 127)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(9, 115, 202, 127)); - } - [Fact] public void NormalizedShort2() { @@ -1173,87 +1083,6 @@ namespace SixLabors.ImageSharp.Tests.Colors Assert.Equal(argb32, expectedArgb32); } - [Fact] - public void NormalizedShort4() - { - if (TestEnvironment.IsLinux) - { - // Can't decide if these assertions are robust enough to be portable across CPU architectures. - // Let's just skip it for 32 bits! - // TODO: Someone should review this! - // see https://github.com/SixLabors/ImageSharp/issues/594 - return; - } - - // Test 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); - - // 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())); - - // Test ToScaledVector4. - Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(NormalizedShort4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, pixel.PackedValue); - - // Test Ordering - float x = 0.1f; - float y = -0.3f; - float z = 0.5f; - float w = -0.7f; - Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue); - Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 192)); - - new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); - - new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(141, 90, 192)); - - new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 192, 39)); - - new NormalizedShort4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 192, 39)); - - var r = default(NormalizedShort4); - r.PackFromRgba32(new Rgba32(9, 115, 202, 127)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(9, 115, 202, 127)); - - r = default(NormalizedShort4); - r.PackFromBgra32(new Bgra32(9, 115, 202, 127)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(9, 115, 202, 127)); - - r = default(NormalizedShort4); - r.PackFromArgb32(new Argb32(9, 115, 202, 127)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(9, 115, 202, 127)); - } - [Fact] public void Rg32() { @@ -1663,8 +1492,8 @@ namespace SixLabors.ImageSharp.Tests.Colors var short2 = new Short4(Vector4.One * -1234567.0f); // act - var vector1 = short1.ToVector4(); - var vector2 = short2.ToVector4(); + var vector1 = short1.ToVector4(); + var vector2 = short2.ToVector4(); // assert Assert.Equal(Vector4.One * 0x7FFF, vector1); @@ -1794,98 +1623,6 @@ namespace SixLabors.ImageSharp.Tests.Colors Assert.Equal(argb32, expectedArgb32); } - [Fact] - public void Short4() - { - if (TestEnvironment.IsLinux) - { - // Can't decide if these assertions are robust enough to be portable across CPU architectures. - // Let's just skip it for 32 bits! - // TODO: Someone should review this! - // see https://github.com/SixLabors/ImageSharp/issues/594 - return; - } - - // Test the limits. - Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); - Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); - Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); - - // Test ToVector4. - Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4()); - Assert.Equal(Vector4.UnitX * 0x7FFF, new Short4(Vector4.UnitX * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.UnitY * 0x7FFF, new Short4(Vector4.UnitY * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.UnitZ * 0x7FFF, new Short4(Vector4.UnitZ * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.UnitW * 0x7FFF, new Short4(Vector4.UnitW * 0x7FFF).ToVector4()); - - // Test ToScaledVector4. - Vector4 scaled = new Short4(Vector4.One * 0x7FFF).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(Short4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, pixel.PackedValue); - - // Test clamping. - Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 1234567.0f).ToVector4()); - Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -1234567.0f).ToVector4()); - - // Test Ordering - float x = 0.1f; - float y = -0.3f; - float z = 0.5f; - float w = -0.7f; - Assert.Equal(18446462598732840960, new Short4(x, y, z, w).PackedValue); - - x = 11547; - y = 12653; - z = 29623; - w = 193; - Assert.Equal((ulong)0x00c173b7316d2d1b, new Short4(x, y, z, w).PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Short4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(172, 177, 243)); // this seems to be causing the problem #594 - - new Short4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(172, 177, 243, 128)); - - new Short4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(172, 177, 243)); - - new Short4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(172, 177, 243, 128)); - - new Short4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(172, 177, 243, 128)); - - var r = default(Short4); - r.PackFromRgba32(new Rgba32(20, 38, 0, 255)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 0, 255)); - - r = default(Short4); - r.PackFromBgra32(new Bgra32(20, 38, 0, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 0, 255)); - - r = default(Short4); - r.PackFromArgb32(new Argb32(20, 38, 0, 255)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(20, 38, 0, 255)); - } - // Comparison helpers with small tolerance to allow for floating point rounding during computations. public static bool Equal(float a, float b) { From 9f1529ed7fabcfff80fda53b4a0fd91d20d08934 Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 27 May 2018 19:52:06 +0200 Subject: [PATCH 08/17] moved NormalizedByte4, NormalizedShort4, Short4 test to a separate file to be able to reproduce #594. Note: the refactored better isolated tests do not produce the error --- tests/ImageSharp.Tests/Issues/Issue594.cs | 263 ++++++++++++++++++++++ 1 file changed, 263 insertions(+) create mode 100644 tests/ImageSharp.Tests/Issues/Issue594.cs diff --git a/tests/ImageSharp.Tests/Issues/Issue594.cs b/tests/ImageSharp.Tests/Issues/Issue594.cs new file mode 100644 index 000000000..73be612c1 --- /dev/null +++ b/tests/ImageSharp.Tests/Issues/Issue594.cs @@ -0,0 +1,263 @@ +using System; +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.Issues +{ + public class Issue594 + { + // This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue + // see https://github.com/SixLabors/ImageSharp/issues/594 + [Fact(Skip = "Skipped because of issue #594")] + public void NormalizedByte4() + { + // Test PackedValue + Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); + Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); + Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); + + // Test ToVector4 + Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4())); + Assert.True(Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4())); + Assert.True(Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4())); + + // Test ToScaledVector4. + Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); + Assert.Equal(0, scaled.X); + Assert.Equal(0, scaled.Y); + Assert.Equal(0, scaled.Z); + Assert.Equal(0, scaled.W); + + // Test PackFromScaledVector4. + var pixel = default(NormalizedByte4); + pixel.PackFromScaledVector4(scaled); + Assert.Equal(0x81818181, pixel.PackedValue); + + // Test Ordering + float x = 0.1f; + float y = -0.3f; + float z = 0.5f; + float w = -0.7f; + Assert.Equal(0xA740DA0D, new NormalizedByte4(x, y, z, w).PackedValue); + var n = default(NormalizedByte4); + n.PackFromRgba32(new Rgba32(141, 90, 192, 39)); + Assert.Equal(0xA740DA0D, n.PackedValue); + + Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); + + var rgb = default(Rgb24); + var rgba = default(Rgba32); + var bgr = default(Bgr24); + var bgra = default(Bgra32); + var argb = default(Argb32); + + new NormalizedByte4(x, y, z, w).ToRgb24(ref rgb); + Assert.Equal(rgb, new Rgb24(141, 90, 192)); + + new NormalizedByte4(x, y, z, w).ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); + + new NormalizedByte4(x, y, z, w).ToBgr24(ref bgr); + Assert.Equal(bgr, new Bgr24(141, 90, 192)); + + new NormalizedByte4(x, y, z, w).ToBgra32(ref bgra); + Assert.Equal(bgra, new Bgra32(141, 90, 192, 39)); + + new NormalizedByte4(x, y, z, w).ToArgb32(ref argb); + Assert.Equal(argb, new Argb32(141, 90, 192, 39)); + + // http://community.monogame.net/t/normalizedbyte4-texture2d-gives-different-results-from-xna/8012/8 + var r = default(NormalizedByte4); + r.PackFromRgba32(new Rgba32(9, 115, 202, 127)); + r.ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(9, 115, 202, 127)); + + r.PackedValue = 0xff4af389; + r.ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(9, 115, 202, 127)); + + r = default(NormalizedByte4); + r.PackFromArgb32(new Argb32(9, 115, 202, 127)); + r.ToArgb32(ref argb); + Assert.Equal(argb, new Argb32(9, 115, 202, 127)); + + r = default(NormalizedByte4); + r.PackFromBgra32(new Bgra32(9, 115, 202, 127)); + r.ToBgra32(ref bgra); + Assert.Equal(bgra, new Bgra32(9, 115, 202, 127)); + } + + // This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue + // see https://github.com/SixLabors/ImageSharp/issues/594 + [Fact(Skip = "Skipped because of issue #594")] + public void NormalizedShort4() + { + // Test 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); + + // 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())); + + // Test ToScaledVector4. + Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); + Assert.Equal(1, scaled.X); + Assert.Equal(1, scaled.Y); + Assert.Equal(1, scaled.Z); + Assert.Equal(1, scaled.W); + + // Test PackFromScaledVector4. + var pixel = default(NormalizedShort4); + pixel.PackFromScaledVector4(scaled); + Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, pixel.PackedValue); + + // Test Ordering + float x = 0.1f; + float y = -0.3f; + float z = 0.5f; + float w = -0.7f; + Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue); + Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); + + var rgb = default(Rgb24); + var rgba = default(Rgba32); + var bgr = default(Bgr24); + var bgra = default(Bgra32); + var argb = default(Argb32); + + new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb); + Assert.Equal(rgb, new Rgb24(141, 90, 192)); + + new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); + + new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr); + Assert.Equal(bgr, new Bgr24(141, 90, 192)); + + new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra); + Assert.Equal(bgra, new Bgra32(141, 90, 192, 39)); + + new NormalizedShort4(x, y, z, w).ToArgb32(ref argb); + Assert.Equal(argb, new Argb32(141, 90, 192, 39)); + + var r = default(NormalizedShort4); + r.PackFromRgba32(new Rgba32(9, 115, 202, 127)); + r.ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(9, 115, 202, 127)); + + r = default(NormalizedShort4); + r.PackFromBgra32(new Bgra32(9, 115, 202, 127)); + r.ToBgra32(ref bgra); + Assert.Equal(bgra, new Bgra32(9, 115, 202, 127)); + + r = default(NormalizedShort4); + r.PackFromArgb32(new Argb32(9, 115, 202, 127)); + r.ToArgb32(ref argb); + Assert.Equal(argb, new Argb32(9, 115, 202, 127)); + } + + // This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue + // see https://github.com/SixLabors/ImageSharp/issues/594 + [Fact(Skip = "Skipped because of issue #594")] + public void Short4() + { + // Test the limits. + Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); + Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); + Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); + + // Test ToVector4. + Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4()); + Assert.Equal(Vector4.UnitX * 0x7FFF, new Short4(Vector4.UnitX * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitY * 0x7FFF, new Short4(Vector4.UnitY * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitZ * 0x7FFF, new Short4(Vector4.UnitZ * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitW * 0x7FFF, new Short4(Vector4.UnitW * 0x7FFF).ToVector4()); + + // Test ToScaledVector4. + Vector4 scaled = new Short4(Vector4.One * 0x7FFF).ToScaledVector4(); + Assert.Equal(1, scaled.X); + Assert.Equal(1, scaled.Y); + Assert.Equal(1, scaled.Z); + Assert.Equal(1, scaled.W); + + // Test PackFromScaledVector4. + var pixel = default(Short4); + pixel.PackFromScaledVector4(scaled); + Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, pixel.PackedValue); + + // Test clamping. + Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 1234567.0f).ToVector4()); + Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -1234567.0f).ToVector4()); + + // Test Ordering + float x = 0.1f; + float y = -0.3f; + float z = 0.5f; + float w = -0.7f; + Assert.Equal(18446462598732840960, new Short4(x, y, z, w).PackedValue); + + x = 11547; + y = 12653; + z = 29623; + w = 193; + Assert.Equal((ulong)0x00c173b7316d2d1b, new Short4(x, y, z, w).PackedValue); + + var rgb = default(Rgb24); + var rgba = default(Rgba32); + var bgr = default(Bgr24); + var bgra = default(Bgra32); + var argb = default(Argb32); + + new Short4(x, y, z, w).ToRgb24(ref rgb); + Assert.Equal(rgb, new Rgb24(172, 177, 243)); // this seems to be causing the problem #594 + + new Short4(x, y, z, w).ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(172, 177, 243, 128)); + + new Short4(x, y, z, w).ToBgr24(ref bgr); + Assert.Equal(bgr, new Bgr24(172, 177, 243)); + + new Short4(x, y, z, w).ToBgra32(ref bgra); + Assert.Equal(bgra, new Bgra32(172, 177, 243, 128)); + + new Short4(x, y, z, w).ToArgb32(ref argb); + Assert.Equal(argb, new Argb32(172, 177, 243, 128)); + + var r = default(Short4); + r.PackFromRgba32(new Rgba32(20, 38, 0, 255)); + r.ToRgba32(ref rgba); + Assert.Equal(rgba, new Rgba32(20, 38, 0, 255)); + + r = default(Short4); + r.PackFromBgra32(new Bgra32(20, 38, 0, 255)); + r.ToBgra32(ref bgra); + Assert.Equal(bgra, new Bgra32(20, 38, 0, 255)); + + r = default(Short4); + r.PackFromArgb32(new Argb32(20, 38, 0, 255)); + r.ToArgb32(ref argb); + Assert.Equal(argb, new Argb32(20, 38, 0, 255)); + } + + // Comparison helpers with small tolerance to allow for floating point rounding during computations. + public static bool Equal(float a, float b) + { + return Math.Abs(a - b) < 1e-5; + } + + public static bool Equal(Vector4 a, Vector4 b) + { + return Equal(a.X, b.X) && Equal(a.Y, b.Y) && Equal(a.Z, b.Z) && Equal(a.W, b.W); + } + } +} From adb94ee3f9b747d70885bbac56505dc191651f53 Mon Sep 17 00:00:00 2001 From: popow Date: Tue, 29 May 2018 20:18:27 +0200 Subject: [PATCH 09/17] refactored short2 tests --- .../PixelFormats/PackedPixelTests.cs | 166 ++++++++++++++---- 1 file changed, 129 insertions(+), 37 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 7e9d5dffa..06b6aaa61 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -710,7 +710,6 @@ namespace SixLabors.ImageSharp.Tests.Colors [Fact] public void NormalizedByte4_ToVector4() { - // Test ToVector4 Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4())); Assert.True(Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4())); Assert.True(Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4())); @@ -831,13 +830,13 @@ namespace SixLabors.ImageSharp.Tests.Colors // arrange var bgra32 = default(Bgra32); var short4 = default(NormalizedByte4); + var expectedBgra32 = new Bgra32(9, 115, 202, 127); // act - short4.PackFromBgra32(new Bgra32(9, 115, 202, 127)); + short4.PackFromBgra32(expectedBgra32); short4.ToBgra32(ref bgra32); // assert - var expectedBgra32 = new Bgra32(9, 115, 202, 127); Assert.Equal(bgra32, expectedBgra32); } @@ -1355,72 +1354,165 @@ namespace SixLabors.ImageSharp.Tests.Colors } [Fact] - public void Short2() + public void Short2_PackedValues() { + // Test ordering + Assert.Equal((uint)0x361d2db1, new Short2(0x2db1, 0x361d).PackedValue); + Assert.Equal(4294639744, new Short2(127.5f, -5.3f).PackedValue); // Test the limits. Assert.Equal((uint)0x0, new Short2(Vector2.Zero).PackedValue); Assert.Equal((uint)0x7FFF7FFF, new Short2(Vector2.One * 0x7FFF).PackedValue); Assert.Equal(0x80008000, new Short2(Vector2.One * -0x8000).PackedValue); + } - // Test ToVector2. + [Fact] + public void Short2_ToVector2() + { Assert.True(Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 0x7FFF).ToVector2())); Assert.True(Equal(Vector2.Zero, new Short2(Vector2.Zero).ToVector2())); Assert.True(Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -0x8000).ToVector2())); Assert.True(Equal(Vector2.UnitX * 0x7FFF, new Short2(Vector2.UnitX * 0x7FFF).ToVector2())); Assert.True(Equal(Vector2.UnitY * 0x7FFF, new Short2(Vector2.UnitY * 0x7FFF).ToVector2())); + } - // Test clamping. - Assert.True(Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 1234567.0f).ToVector2())); - Assert.True(Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -1234567.0f).ToVector2())); - - // Test ToVector4. + [Fact] + public void Short2_ToVector4() + { Assert.True(Equal(new Vector4(0x7FFF, 0x7FFF, 0, 1), (new Short2(Vector2.One * 0x7FFF)).ToVector4())); Assert.True(Equal(new Vector4(0, 0, 0, 1), (new Short2(Vector2.Zero)).ToVector4())); Assert.True(Equal(new Vector4(-0x8000, -0x8000, 0, 1), (new Short2(Vector2.One * -0x8000)).ToVector4())); + } - // Test ToScaledVector4. - Vector4 scaled = new Short2(Vector2.One * 0x7FFF).ToScaledVector4(); + [Fact] + public void Short2_Clamping() + { + Assert.True(Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 1234567.0f).ToVector2())); + Assert.True(Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -1234567.0f).ToVector2())); + } + + [Fact] + public void Short2_ToScaledVector4() + { + // arrange + var short2 = new Short2(Vector2.One * 0x7FFF); + + // act + Vector4 scaled = short2.ToScaledVector4(); + + // assert Assert.Equal(1, scaled.X); Assert.Equal(1, scaled.Y); Assert.Equal(0, scaled.Z); Assert.Equal(1, scaled.W); + } - // Test PackFromScaledVector4. + [Fact] + public void Short2_PackFromScaledVector4() + { + // arrange var pixel = default(Short2); + var short2 = new Short2(Vector2.One * 0x7FFF); + ulong expectedPackedValue = 0x7FFF7FFF; + + // act + Vector4 scaled = short2.ToScaledVector4(); pixel.PackFromScaledVector4(scaled); - Assert.Equal((uint)0x7FFF7FFF, pixel.PackedValue); - // Test ordering - float x = 0x2db1; - float y = 0x361d; - Assert.Equal((uint)0x361d2db1, new Short2(x, y).PackedValue); - x = 127.5f; - y = -5.3f; - Assert.Equal(4294639744, new Short2(x, y).PackedValue); + // assert + Assert.Equal(expectedPackedValue, pixel.PackedValue); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); + [Fact] + public void Short2_ToRgb24() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var rgb24 = default(Rgb24); + var expectedRgb24 = new Rgb24(128, 127, 0); - new Short2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 127, 0)); + // act + short2.ToRgb24(ref rgb24); - new Short2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 127, 0, 255)); + // assert + Assert.Equal(expectedRgb24, rgb24); + } - new Short2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 127, 0)); + [Fact] + public void Short2_ToRgba32() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var rgba32 = default(Rgba32); + var expectedRgba32 = new Rgba32(128, 127, 0, 255); - new Short2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 127, 0, 255)); + // act + short2.ToRgba32(ref rgba32); - var r = default(Short2); - r.PackFromRgba32(new Rgba32(20, 38, 0, 255)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 0, 255)); + // assert + Assert.Equal(expectedRgba32, rgba32); + } + + [Fact] + public void Short2_ToBgr24() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var bgr24 = default(Bgr24); + + // act + short2.ToBgr24(ref bgr24); + + // assert + var expectedBgr24 = new Bgr24(128, 127, 0); + Assert.Equal(expectedBgr24, bgr24); + } + + [Fact] + public void Short2_ToArgb32() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var argb32 = default(Argb32); + var expectedArgb32 = new Argb32(128, 127, 0, 255); + + // act + short2.ToArgb32(ref argb32); + + // assert + Assert.Equal(expectedArgb32, argb32); } + [Fact] + public void Short2_ToBgra32() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var bgra32 = default(Bgra32); + var expectedBgra32 = new Bgra32(128, 127, 0, 255); + + // act + short2.ToBgra32(ref bgra32); + + // assert + Assert.Equal(expectedBgra32, bgra32); + } + + [Fact] + public void Short2_PackFromRgba32_ToRgba32() + { + // arrange + var rgba32 = default(Rgba32); + var short2 = default(Short2); + var expectedRgba32 = new Rgba32(20, 38, 0, 255); + + // act + short2.PackFromRgba32(expectedRgba32); + short2.ToRgba32(ref rgba32); + + // assert + Assert.Equal(rgba32, expectedRgba32); + } + [Fact] public void Short4_PackedValues() { From 97d280eeb659a900055565c509a0ad039219d0b7 Mon Sep 17 00:00:00 2001 From: popow Date: Sat, 2 Jun 2018 16:26:26 +0200 Subject: [PATCH 10/17] refactored remaining packed pixel tests --- .../PixelFormats/PackedPixelTests.cs | 3406 ++++++++++++----- 1 file changed, 2382 insertions(+), 1024 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 06b6aaa61..cd0435c4a 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Tests.Colors public class PackedPixelTests { [Fact] - public void Alpha8() + public void Alpha8_PackedValue() { // Test the limits. Assert.Equal(0x0, new Alpha8(0F).PackedValue); @@ -31,1326 +31,2688 @@ namespace SixLabors.ImageSharp.Tests.Colors // Test ordering Assert.Equal(124, new Alpha8(124F / 0xFF).PackedValue); Assert.Equal(26, new Alpha8(0.1F).PackedValue); + } + + [Fact] + public void Alpha8_ToVector4() + { + // arrange + var alpha = new Alpha8(.5F); + + // act + var actual = alpha.ToVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(.5F, actual.W, 2); + } + + [Fact] + public void Alpha8_ToScaledVector4() + { + // arrange + var alpha = new Alpha8(.5F); + + // act + Vector4 actual = alpha.ToScaledVector4(); - // Test ToVector4. - var vector = new Alpha8(.5F).ToVector4(); - Assert.Equal(0, vector.X); - Assert.Equal(0, vector.Y); - Assert.Equal(0, vector.Z); - Assert.Equal(.5F, vector.W, 2); + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(.5F, actual.W, 2); + } - // Test ToScaledVector4. + [Fact] + public void Alpha8_PackFromScaledVector4() + { + // arrange + Alpha8 alpha = default; + int expected = 128; Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(.5F, scaled.W, 2); - // Test PackFromScaledVector4. + // act + alpha.PackFromScaledVector4(scaled); + byte actual = alpha.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToRgb24() + { + // arrange + Rgb24 actual = default; Alpha8 alpha = default; + var expected = new Rgb24(0, 0, 0); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act alpha.PackFromScaledVector4(scaled); - Assert.Equal(128, alpha.PackedValue); + alpha.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } - // Test Rgb conversion - Rgb24 rgb = default; - Rgba32 rgba = default; - Bgr24 bgr = default; - Bgra32 bgra = default; - Argb32 argb = default; + [Fact] + public void Alpha8_PackFromScaledVector4_ToRgba32() + { + // arrange + Rgba32 actual = default; + Alpha8 alpha = default; + var expected = new Rgba32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - alpha.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0, 0, 0)); + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToRgba32(ref actual); - alpha.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0, 0, 0, 128)); + // assert + Assert.Equal(expected, actual); + } - alpha.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0, 0, 0)); + [Fact] + public void Alpha8_PackFromScaledVector4_ToBgr24() + { + // arrange + Bgr24 actual = default; + Alpha8 alpha = default; + var expected = new Bgr24(0, 0, 0); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - alpha.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0, 0, 0, 128)); + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToBgr24(ref actual); - alpha.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0, 0, 0, 128)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Argb32() + public void Alpha8_PackFromScaledVector4_ToBgra32() { - // Test the limits. + // arrange + Bgra32 actual = default; + Alpha8 alpha = default; + var expected = new Bgra32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToArgb32() + { + // arrange + Alpha8 alpha = default; + Argb32 actual = default; + var expected = new Argb32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_PackedValue() + { + Assert.Equal(0x80001a00u, new Argb32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); Assert.Equal((uint)0x0, new Argb32(Vector4.Zero).PackedValue); Assert.Equal(0xFFFFFFFF, new Argb32(Vector4.One).PackedValue); + } - // Test ToVector4. - Assert.True(Equal(Vector4.One, new Argb32(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Argb32(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new Argb32(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new Argb32(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new Argb32(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new Argb32(Vector4.UnitW).ToVector4())); + [Fact] + public void Argb32_ToVector4() + { + Assert.Equal(Vector4.One, new Argb32(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new Argb32(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX, new Argb32(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new Argb32(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new Argb32(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new Argb32(Vector4.UnitW).ToVector4()); + } - // Test ToScaledVector4. - Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + [Fact] + public void Argb32_ToScaledVector4() + { + // arrange + var argb = new Argb32(Vector4.One); + + // act + Vector4 actual = argb.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } - // Test PackFromScaledVector4. + [Fact] + public void Argb32_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4(); var pixel = default(Argb32); + uint expected = 0xFFFFFFFF; + + // act pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); + uint actual = pixel.PackedValue; - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4())); + // assert + Assert.Equal(expected, actual); + } - float x = +0.1f; - float y = -0.3f; - float z = +0.5f; - float w = -0.7f; - var argb = new Argb32(x, y, z, w); - Assert.Equal(0x80001a00u, argb.PackedValue); + [Fact] + public void Argb32_Clamping() + { + Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4()); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb2 = default(Argb32); + [Fact] + public void Argb32_ToRgb24() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(0x1a, 0, 0x80); - argb.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80)); + // act + argb.ToRgb24(ref actual); - argb.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); - Assert.Equal(rgba, argb.ToRgba32()); + // assert + Assert.Equal(expected, actual); + } - argb.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80)); + [Fact] + public void Argb32_ToRgba32() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); - argb.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - Assert.Equal(bgra, argb.ToBgra32()); + // act + argb.ToRgba32(ref actual); - argb.ToArgb32(ref argb2); - Assert.Equal(argb2, new Argb32(0x1a, 0, 0x80, 0)); - Assert.Equal(argb2, argb.ToArgb32()); + // assert + Assert.Equal(expected, actual); + } - var r = default(Argb32); - r.PackFromRgba32(new Rgba32(0x1a, 0, 0x80, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); + [Fact] + public void Argb32_ToBgr24() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(0x1a, 0, 0x80); - r = default(Argb32); - r.PackFromBgra32(new Bgra32(0x1a, 0, 0x80, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); + // act + argb.ToBgr24(ref actual); - r = default(Argb32); - r.PackFromArgb32(new Argb32(0x1a, 0, 0x80, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Bgr565() + public void Argb32_ToBgra32() { - // Test the limits. - Assert.Equal(0x0, new Bgr565(Vector3.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgr565(Vector3.One).PackedValue); - - // Test ToVector3. - Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One).ToVector3())); - Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.Zero).ToVector3())); - Assert.True(Equal(Vector3.UnitX, new Bgr565(Vector3.UnitX).ToVector3())); - Assert.True(Equal(Vector3.UnitY, new Bgr565(Vector3.UnitY).ToVector3())); - Assert.True(Equal(Vector3.UnitZ, new Bgr565(Vector3.UnitZ).ToVector3())); + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); - // Test ToScaledVector4. - Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // act + argb.ToBgra32(ref actual); - // Test PackFromScaledVector4. - var pixel = default(Bgr565); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test clamping. - Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3())); - Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3())); + [Fact] + public void Argb32_ToArgb32() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - // Make sure the swizzle is correct. - Assert.Equal(0xF800, new Bgr565(Vector3.UnitX).PackedValue); - Assert.Equal(0x07E0, new Bgr565(Vector3.UnitY).PackedValue); - Assert.Equal(0x001F, new Bgr565(Vector3.UnitZ).PackedValue); + // act + argb.ToArgb32(ref actual); - float x = 0.1F; - float y = -0.3F; - float z = 0.5F; - Assert.Equal(6160, new Bgr565(x, y, z).PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); + [Fact] + public void Argb32_PackFromRgba32_ToRgba32() + { + // arrange var argb = default(Argb32); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); - new Bgr565(x, y, z).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(25, 0, 132)); + // act + argb.PackFromRgba32(expected); + argb.ToRgba32(ref actual); - new Bgr565(x, y, z).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 132, 255)); + // assert + Assert.Equal(expected, actual); + } - new Bgr565(x, y, z).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(25, 0, 132)); + [Fact] + public void Argb32_PackFromBgra32_ToBgra32() + { + // arrange + var argb = default(Argb32); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); - new Bgr565(x, y, z).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 132, 255)); + // act + argb.PackFromBgra32(expected); + argb.ToBgra32(ref actual); - new Bgr565(x, y, z).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 132, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Bgra4444() + public void Argb32_PackFromArgb32_ToArgb32() { - // Test the limits. - Assert.Equal(0x0, new Bgra4444(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgra4444(Vector4.One).PackedValue); - - // Test ToVector4. - Assert.True(Equal(Vector4.One, new Bgra4444(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Bgra4444(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new Bgra4444(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new Bgra4444(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new Bgra4444(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new Bgra4444(Vector4.UnitW).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // arrange + var argb = default(Argb32); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - // Test PackFromScaledVector4. - var pixel = default(Bgra4444); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); + // act + argb.PackFromArgb32(expected); + argb.ToArgb32(ref actual); - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4())); + // assert + Assert.Equal(expected, actual); + } + [Fact] + public void Bgr565_PackedValue() + { + Assert.Equal(6160, new Bgr565(0.1F, -0.3F, 0.5F).PackedValue); + Assert.Equal(0x0, new Bgr565(Vector3.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgr565(Vector3.One).PackedValue); // Make sure the swizzle is correct. - Assert.Equal(0x0F00, new Bgra4444(Vector4.UnitX).PackedValue); - Assert.Equal(0x00F0, new Bgra4444(Vector4.UnitY).PackedValue); - Assert.Equal(0x000F, new Bgra4444(Vector4.UnitZ).PackedValue); - Assert.Equal(0xF000, new Bgra4444(Vector4.UnitW).PackedValue); + Assert.Equal(0xF800, new Bgr565(Vector3.UnitX).PackedValue); + Assert.Equal(0x07E0, new Bgr565(Vector3.UnitY).PackedValue); + Assert.Equal(0x001F, new Bgr565(Vector3.UnitZ).PackedValue); + } + + [Fact] + public void Bgr565_ToVector3() + { + Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One).ToVector3())); + Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.Zero).ToVector3())); + Assert.True(Equal(Vector3.UnitX, new Bgr565(Vector3.UnitX).ToVector3())); + Assert.True(Equal(Vector3.UnitY, new Bgr565(Vector3.UnitY).ToVector3())); + Assert.True(Equal(Vector3.UnitZ, new Bgr565(Vector3.UnitZ).ToVector3())); + } - float x = 0.1f; - float y = -0.3f; - float z = 0.5f; - float w = -0.7f; - Assert.Equal(520, new Bgra4444(x, y, z, w).PackedValue); + [Fact] + public void Bgr565_ToScaledVector4() + { + // arrange + var bgr = new Bgr565(Vector3.One); - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + // act + Vector4 actual = bgr.ToScaledVector4(); - new Bgra4444(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(34, 0, 136)); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } - new Bgra4444(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(34, 0, 136, 0)); + [Fact] + public void Bgr565_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4(); + int expected = 0xFFFF; + var pixel = default(Bgr565); - new Bgra4444(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(34, 0, 136)); + // act + pixel.PackFromScaledVector4(scaled); + ushort actual = pixel.PackedValue; - new Bgra4444(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(34, 0, 136, 0)); + // assert + Assert.Equal(expected, actual); + } - new Bgra4444(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(34, 0, 136, 0)); + [Fact] + public void Bgr565_Clamping() + { + Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3()); + Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3()); + } - var r = default(Bgra4444); - r.PackFromRgba32(new Rgba32(34, 0, 136, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(34, 0, 136, 0)); + [Fact] + public void Bgr565_ToRgb24() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 132); - r = default(Bgra4444); - r.PackFromBgra32(new Bgra32(34, 0, 136, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(34, 0, 136, 0)); + // act + bgra.ToRgb24(ref actual); - r = default(Bgra4444); - r.PackFromArgb32(new Argb32(34, 0, 136, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(34, 0, 136, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Bgra5551() + public void Bgr565_ToRgba32() { - // Test the limits. - Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue); + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 132, 255); - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Bgra5551(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Bgra5551(Vector4.One).ToVector4())); + // act + bgra.ToRgba32(ref actual); - // Test ToScaledVector4. - Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // assert + Assert.Equal(expected, actual); + } - // Test PackFromScaledVector4. - var pixel = default(Bgra5551); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); + [Fact] + public void Bgr565_ToBgr24() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 132); - // Test clamping. - Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); - Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); + // act + bgra.ToBgr24(ref actual); - // Test Ordering - float x = 0x1a; - float y = 0x16; - float z = 0xd; - float w = 0x1; - Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue); - x = 0.1f; - y = -0.3f; - z = 0.5f; - w = -0.7f; - Assert.Equal(3088, new Bgra5551(x, y, z, w).PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void Bgr565_ToBgra32() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Bgra32); + var expected = new Bgra32(25, 0, 132, 255); - new Bgra5551(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(24, 0, 131)); + // act + bgra.ToBgra32(ref actual); - new Bgra5551(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(24, 0, 131, 0)); + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgr565_ToArgb32() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Argb32); + var expected = new Argb32(25, 0, 132, 255); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackedValue() + { + Assert.Equal(520, new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal(0x0, new Bgra4444(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgra4444(Vector4.One).PackedValue); + Assert.Equal(0x0F00, new Bgra4444(Vector4.UnitX).PackedValue); + Assert.Equal(0x00F0, new Bgra4444(Vector4.UnitY).PackedValue); + Assert.Equal(0x000F, new Bgra4444(Vector4.UnitZ).PackedValue); + Assert.Equal(0xF000, new Bgra4444(Vector4.UnitW).PackedValue); + } + + [Fact] + public void Bgra4444_ToVector4() + { + Assert.Equal(Vector4.One, new Bgra4444(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX, new Bgra4444(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new Bgra4444(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new Bgra4444(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new Bgra4444(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void Bgra4444_ToScaledVector4() + { + // arrange + var bgra = new Bgra4444(Vector4.One); + + // act + Vector4 actual = bgra.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Bgra4444_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4(); + int expected = 0xFFFF; + var bgra = default(Bgra4444); + + // act + bgra.PackFromScaledVector4(scaled); + ushort actual = bgra.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_Clamping() + { + Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Bgra4444_ToRgb24() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(34, 0, 136); + + // act + bgra.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToRgba32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(34, 0, 136, 0); + + // act + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToBgr24() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(34, 0, 136); + + // act + bgra.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToBgra32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(34, 0, 136, 0); + + // act + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToArgb32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(34, 0, 136, 0); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromRgba32_ToRgba32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Rgba32); + var expected = new Rgba32(34, 0, 136, 0); + + // act + bgra.PackFromRgba32(expected); + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromBgra32_ToBgra32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Bgra32); + var expected = new Bgra32(34, 0, 136, 0); + + // act + bgra.PackFromBgra32(expected); + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromArgb32_ToArgb32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Argb32); + var expected = new Argb32(34, 0, 136, 0); + + // act + bgra.PackFromArgb32(expected); + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackedValue() + { + float x = 0x1a; + float y = 0x16; + float z = 0xd; + float w = 0x1; + Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue); + Assert.Equal(3088, new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + // Test the limits. + Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue); + } + + [Fact] + public void Bgra5551_ToVector4() + { + Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new Bgra5551(Vector4.One).ToVector4()); + } + + [Fact] + public void Bgra5551_ToScaledVector4() + { + // arrange + var bgra = new Bgra5551(Vector4.One); + + // act + Vector4 actual = bgra.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Bgra5551_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4(); + int expected = 0xFFFF; + var pixel = default(Bgra5551); + pixel.PackFromScaledVector4(scaled); + + // act + pixel.PackFromScaledVector4(scaled); + ushort actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Clamping() + { + Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Bgra5551_ToRgb24() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(24, 0, 131); + + // act + bgra.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Rgba32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(24, 0, 131, 0); + + // act + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_ToBgr24() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(24, 0, 131); + + // act + bgra.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Bgra32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(24, 0, 131, 0); + + // act + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_ToArgb32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(24, 0, 131, 0); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromRgba32_ToRgba32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Rgba32(24, 0, 131, 0); + var actual = default(Rgba32); + + // act + bgra.PackFromRgba32(expected); + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromBgra32_ToBgra32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Bgra32(24, 0, 131, 0); + var actual = default(Bgra32); + + // act + bgra.PackFromBgra32(expected); + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromArgb32_ToArgb32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Argb32(24, 0, 131, 0); + var actual = default(Argb32); + + // act + bgra.PackFromArgb32(expected); + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackedValue() + { + Assert.Equal((uint)128, new Byte4(127.5f, -12.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((uint)0x1a7b362d, new Byte4(0x2d, 0x36, 0x7b, 0x1a).PackedValue); + Assert.Equal((uint)0x0, new Byte4(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Byte4(Vector4.One * 255).PackedValue); + } + + [Fact] + public void Byte4_ToVector4() + { + Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 255).ToVector4()); + Assert.Equal(Vector4.Zero, new Byte4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX * 255, new Byte4(Vector4.UnitX * 255).ToVector4()); + Assert.Equal(Vector4.UnitY * 255, new Byte4(Vector4.UnitY * 255).ToVector4()); + Assert.Equal(Vector4.UnitZ * 255, new Byte4(Vector4.UnitZ * 255).ToVector4()); + Assert.Equal(Vector4.UnitW * 255, new Byte4(Vector4.UnitW * 255).ToVector4()); + } + + [Fact] + public void Byte4_ToScaledVector4() + { + // arrange + var byte4 = new Byte4(Vector4.One * 255); + + // act + Vector4 actual = byte4.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Byte4_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4(); + var pixel = default(Byte4); + uint expected = 0xFFFFFFFF; + + // act + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Clamping() + { + Assert.True(Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4())); + Assert.True(Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4())); + } + + [Fact] + public void Byte4_ToRgb24() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(128, 0, 0); + + // act + byte4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Rgba32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(128, 0, 0, 0); + + // act + byte4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_ToBgr24() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(128, 0, 0); + + // act + byte4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Bgra32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(128, 0, 0, 0); + + // act + byte4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Argb32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(128, 0, 0, 0); + + // act + byte4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromRgba32_ToRgba32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); + + // act + byte4.PackFromRgba32(expected); + byte4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromBgra32_ToBgra32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 0, 255); + + // act + byte4.PackFromBgra32(expected); + byte4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromArgb32_ToArgb32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Argb32); + var expected = new Argb32(20, 38, 0, 255); + + // act + byte4.PackFromArgb32(expected); + byte4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_PackedValue() + { + Assert.Equal(11878, new HalfSingle(0.1F).PackedValue); + Assert.Equal(46285, new HalfSingle(-0.3F).PackedValue); + + // Test limits + Assert.Equal(15360, new HalfSingle(1F).PackedValue); + Assert.Equal(0, new HalfSingle(0F).PackedValue); + Assert.Equal(48128, new HalfSingle(-1F).PackedValue); + } + + [Fact] + public void HalfSingle_ToVector4() + { + // arrange + var halfSingle = new HalfSingle(0.5f); + var expected = new Vector4(0.5f, 0, 0, 1); + + // act + var actual = halfSingle.ToVector4(); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToScaledVector4() + { + // arrange + var halfSingle = new HalfSingle(-1F); + + // act + Vector4 actual = halfSingle.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void HalfSingle_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new HalfSingle(-1F).ToScaledVector4(); + int expected = 48128; + var halfSingle = default(HalfSingle); + + // act + halfSingle.PackFromScaledVector4(scaled); + ushort actual = halfSingle.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToRgb24() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Rgb24); + var expected = new Rgb24(128, 0, 0); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Rgba32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Rgba32); + var expected = new Rgba32(128, 0, 0, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToBgr24() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Bgr24); + var expected = new Bgr24(128, 0, 0); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Bgra32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Bgra32); + var expected = new Bgra32(128, 0, 0, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Argb32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Argb32); + var expected = new Argb32(128, 0, 0, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_PackedValue() + { + Assert.Equal(0u, new HalfVector2(Vector2.Zero).PackedValue); + Assert.Equal(1006648320u, new HalfVector2(Vector2.One).PackedValue); + Assert.Equal(3033345638u, new HalfVector2(0.1f, -0.3f).PackedValue); + } + + [Fact] + public void HalfVector2_ToVector2() + { + Assert.True(Equal(Vector2.Zero, new HalfVector2(Vector2.Zero).ToVector2())); + Assert.True(Equal(Vector2.One, new HalfVector2(Vector2.One).ToVector2())); + Assert.True(Equal(Vector2.UnitX, new HalfVector2(Vector2.UnitX).ToVector2())); + Assert.True(Equal(Vector2.UnitY, new HalfVector2(Vector2.UnitY).ToVector2())); + } + + [Fact] + public void HalfVector2_ToScaledVector4() + { + // arrange + var halfVector = new HalfVector2(Vector2.One); + + // act + Vector4 actual = halfVector.ToScaledVector4(); + + // assert + Assert.Equal(1F, actual.X); + Assert.Equal(1F, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void HalfVector2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4(); + uint expected = 1006648320u; + var halfVector = default(HalfVector2); + + // act + halfVector.PackFromScaledVector4(scaled); + uint actual = halfVector.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToVector4() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var expected = new Vector4(0.5f, .25F, 0, 1); + + // act + var actual = halfVector.ToVector4(); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToRgb24() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Rgb24); + var expected = new Rgb24(128, 64, 0); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Rgba32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Rgba32); + var expected = new Rgba32(128, 64, 0, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToBgr24() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Bgr24); + var expected = new Bgr24(128, 64, 0); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Bgra32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Bgra32); + var expected = new Bgra32(128, 64, 0, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Argb32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Argb32); + var expected = new Argb32(128, 64, 0, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackedValue() + { + Assert.Equal(0uL, new HalfVector4(Vector4.Zero).PackedValue); + Assert.Equal(4323521613979991040uL, new HalfVector4(Vector4.One).PackedValue); + Assert.Equal(13547034390470638592uL, new HalfVector4(-Vector4.One).PackedValue); + Assert.Equal(15360uL, new HalfVector4(Vector4.UnitX).PackedValue); + Assert.Equal(1006632960uL, new HalfVector4(Vector4.UnitY).PackedValue); + Assert.Equal(65970697666560uL, new HalfVector4(Vector4.UnitZ).PackedValue); + Assert.Equal(4323455642275676160uL, new HalfVector4(Vector4.UnitW).PackedValue); + Assert.Equal(4035285078724390502uL, new HalfVector4(0.1f, 0.3f, 0.4f, 0.5f).PackedValue); + } + + [Fact] + public void HalfVector4_ToVector4() + { + Assert.Equal(Vector4.Zero, new HalfVector4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new HalfVector4(Vector4.One).ToVector4()); + Assert.Equal(-Vector4.One, new HalfVector4(-Vector4.One).ToVector4()); + Assert.Equal(Vector4.UnitX, new HalfVector4(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new HalfVector4(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new HalfVector4(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new HalfVector4(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void HalfVector4_ToScaledVector4() + { + // arrange + var halfVector4 = new HalfVector4(-Vector4.One); + + // act + Vector4 actual = halfVector4.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(0, actual.W); + } + + [Fact] + public void HalfVector4_PackFromScaledVector4() + { + // arrange + var halfVector4 = default(HalfVector4); + Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4(); + ulong expected = 13547034390470638592uL; + + // act + halfVector4.PackFromScaledVector4(scaled); + ulong actual = halfVector4.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_ToRgb24() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Rgb24); + var expected = new Rgb24(64, 128, 191); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Rgba32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Rgba32); + var expected = new Rgba32(64, 128, 191, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_ToBgr24() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Bgr24); + var expected = new Bgr24(64, 128, 191); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Bgra32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Bgra32); + var expected = new Bgra32(64, 128, 191, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Argb32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Argb32); + var expected = new Argb32(64, 128, 191, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromRgba32_ToRgba32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Rgba32); + var expected = new Rgba32(64, 128, 191, 255); + + // act + halVector.PackFromRgba32(expected); + halVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromBgra32_ToBgra32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Bgra32); + var expected = new Bgra32(64, 128, 191, 255); + + // act + halVector.PackFromBgra32(expected); + halVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromArgb32_ToArgb32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Argb32); + var expected = new Argb32(64, 128, 191, 255); + + // act + halVector.PackFromArgb32(expected); + halVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_PackedValue() + { + Assert.Equal(0xda0d, new NormalizedByte2(0.1f, -0.3f).PackedValue); + Assert.Equal(0x0, new NormalizedByte2(Vector2.Zero).PackedValue); + Assert.Equal(0x7F7F, new NormalizedByte2(Vector2.One).PackedValue); + Assert.Equal(0x8181, new NormalizedByte2(-Vector2.One).PackedValue); + } + + [Fact] + public void NormalizedByte2_ToVector2() + { + Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One).ToVector2()); + Assert.Equal(Vector2.Zero, new NormalizedByte2(Vector2.Zero).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedByte2(-Vector2.One).ToVector2()); + Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One * 1234.0f).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedByte2(Vector2.One * -1234.0f).ToVector2()); + } + + [Fact] + public void NormalizedByte2_ToVector4() + { + Assert.Equal(new Vector4(1, 1, 0, 1), new NormalizedByte2(Vector2.One).ToVector4()); + Assert.Equal(new Vector4(0, 0, 0, 1), new NormalizedByte2(Vector2.Zero).ToVector4()); + } + + [Fact] + public void NormalizedByte2_ToScaledVector4() + { + // arrange + var byte2 = new NormalizedByte2(-Vector2.One); + + // act + Vector4 actual = byte2.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1F, actual.W); + } + + [Fact] + public void NormalizedByte2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4(); + var byte2 = default(NormalizedByte2); + uint expected = 0x8181; + + // act + byte2.PackFromScaledVector4(scaled); + uint actual = byte2.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_PackFromRgba32() + { + // arrange + var byte2 = new NormalizedByte2(); + var rgba = new Rgba32(141, 90, 0, 0); + int expected = 0xda0d; + + // act + byte2.PackFromRgba32(rgba); + ushort actual = byte2.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToRgb24() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 0); + + // act + short4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToRgba32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 0, 255); + + // act + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToBgr24() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 0); + + // act + short4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToBgra32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Bgra32); + var expected = new Bgra32(141, 90, 0, 255); + + // act + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToArgb32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 0, 255); + + // act + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackedValues() + { + Assert.Equal(0xA740DA0D, new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); + Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); + Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); + Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); + } + + [Fact] + public void NormalizedByte4_ToVector4() + { + Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4()); + Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4()); + } + + [Fact] + public void NormalizedByte4_ToScaledVector4() + { + // arrange + var short4 = new NormalizedByte4(-Vector4.One); + + // act + Vector4 actual = short4.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(0, actual.W); + } + + [Fact] + public void NormalizedByte4_PackFromScaledVector4() + { + // arrange + var pixel = default(NormalizedByte4); + Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); + uint expected = 0x81818181; + + // act + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToRgb24() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 192); + + // act + short4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToRgba32() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 192, 39); + + // act + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToBgr24() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 192); + + // act + short4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToArgb32() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 192, 39); + + // act + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromRgba32_ToRgba32() + { + // arrange + var short4 = default(NormalizedByte4); + var actual = default(Rgba32); + var expected = new Rgba32(9, 115, 202, 127); + + // act + short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromBgra32_ToRgba32() + { + // arrange + var actual = default(Bgra32); + var short4 = default(NormalizedByte4); + var expected = new Bgra32(9, 115, 202, 127); + + // act + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromArgb32_ToRgba32() + { + // arrange + var short4 = default(NormalizedByte4); + var actual = default(Argb32); + var expected = new Argb32(9, 115, 202, 127); + + // act + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_PackedValue() + { + Assert.Equal(0xE6672CCC, new NormalizedShort2(0.35f, -0.2f).PackedValue); + Assert.Equal(3650751693, new NormalizedShort2(0.1f, -0.3f).PackedValue); + Assert.Equal((uint)0x0, new NormalizedShort2(Vector2.Zero).PackedValue); + Assert.Equal((uint)0x7FFF7FFF, new NormalizedShort2(Vector2.One).PackedValue); + Assert.Equal(0x80018001, new NormalizedShort2(-Vector2.One).PackedValue); + // TODO: I don't think this can ever pass since the bytes are already truncated. + // Assert.Equal(3650751693, n.PackedValue); + } + + [Fact] + public void NormalizedShort2_ToVector2() + { + Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One).ToVector2())); + Assert.True(Equal(Vector2.Zero, new NormalizedShort2(Vector2.Zero).ToVector2())); + Assert.True(Equal(-Vector2.One, new NormalizedShort2(-Vector2.One).ToVector2())); + Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One * 1234.0f).ToVector2())); + Assert.True(Equal(-Vector2.One, new NormalizedShort2(Vector2.One * -1234.0f).ToVector2())); + } + + [Fact] + public void NormalizedShort2_ToVector4() + { + Assert.True(Equal(new Vector4(1, 1, 0, 1), (new NormalizedShort2(Vector2.One)).ToVector4())); + Assert.True(Equal(new Vector4(0, 0, 0, 1), (new NormalizedShort2(Vector2.Zero)).ToVector4())); + } + + [Fact] + public void NormalizedShort2_ToScaledVector4() + { + // arrange + var short2 = new NormalizedShort2(-Vector2.One); + + // act + Vector4 actual = short2.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } - new Bgra5551(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(24, 0, 131)); + [Fact] + public void NormalizedShort2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4(); + var short2 = default(NormalizedShort2); + uint expected = 0x80018001; - new Bgra5551(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(24, 0, 131, 0)); + // act + short2.PackFromScaledVector4(scaled); + uint actual = short2.PackedValue; - new Bgra5551(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(24, 0, 131, 0)); + // assert + Assert.Equal(expected, actual); + } - var r = default(Bgra5551); - r.PackFromRgba32(new Rgba32(24, 0, 131, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(24, 0, 131, 0)); + [Fact] + public void NormalizedShort2_PackFromRgba32_ToRgb24() + { + // arrange + var actual = default(Rgb24); + var short2 = new NormalizedShort2(); + var rgba = new Rgba32(141, 90, 0, 0); + var expected = new Rgb24(141, 90, 0); - r = default(Bgra5551); - r.PackFromBgra32(new Bgra32(24, 0, 131, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(24, 0, 131, 0)); + // act + short2.PackFromRgba32(rgba); + short2.ToRgb24(ref actual); - r = default(Bgra5551); - r.PackFromArgb32(new Argb32(24, 0, 131, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(24, 0, 131, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Byte4() + public void NormalizedShort2_ToRgb24() { - // Test the limits. - Assert.Equal((uint)0x0, new Byte4(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Byte4(Vector4.One * 255).PackedValue); + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 0); - // Test ToVector4. - Assert.True(Equal(Vector4.One * 255, new Byte4(Vector4.One * 255).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Byte4(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX * 255, new Byte4(Vector4.UnitX * 255).ToVector4())); - Assert.True(Equal(Vector4.UnitY * 255, new Byte4(Vector4.UnitY * 255).ToVector4())); - Assert.True(Equal(Vector4.UnitZ * 255, new Byte4(Vector4.UnitZ * 255).ToVector4())); - Assert.True(Equal(Vector4.UnitW * 255, new Byte4(Vector4.UnitW * 255).ToVector4())); + // act + short2.ToRgb24(ref actual); - // Test ToScaledVector4. - Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // assert + Assert.Equal(expected, actual); + } - // Test PackFromScaledVector4. - var pixel = default(Byte4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); + [Fact] + public void NormalizedShort2_ToRgba32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 0, 255); - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4())); + // act + short2.ToRgba32(ref actual); - // Test ordering - float x = 0x2d; - float y = 0x36; - float z = 0x7b; - float w = 0x1a; - Assert.Equal((uint)0x1a7b362d, new Byte4(x, y, z, w).PackedValue); - - x = 127.5f; - y = -12.3f; - z = 0.5f; - w = -0.7f; - Assert.Equal((uint)128, new Byte4(x, y, z, w).PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort2_ToBgr24() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 0); - new Byte4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 0, 0)); + // act + short2.ToBgr24(ref actual); - new Byte4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 0, 0, 0)); + // assert + Assert.Equal(expected, actual); + } - new Byte4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 0, 0)); + [Fact] + public void NormalizedShort2_ToBgra32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Bgra32); + var expected = new Bgra32(141, 90, 0, 255); - new Byte4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 0, 0, 0)); + // act + short2.ToBgra32(ref actual); - new Byte4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 0, 0, 0)); + // assert + Assert.Equal(expected, actual); + } - var r = default(Byte4); - r.PackFromRgba32(new Rgba32(20, 38, 0, 255)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 0, 255)); + [Fact] + public void NormalizedShort2_ToArgb32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 0, 255); - r = default(Byte4); - r.PackFromBgra32(new Bgra32(20, 38, 0, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 0, 255)); + // act + short2.ToArgb32(ref actual); - r = default(Byte4); - r.PackFromArgb32(new Argb32(20, 38, 0, 255)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(20, 38, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void HalfSingle() + public void NormalizedShort4_PackedValues() { - // Test limits - Assert.Equal(15360, new HalfSingle(1F).PackedValue); - Assert.Equal(0, new HalfSingle(0F).PackedValue); - Assert.Equal(48128, new HalfSingle(-1F).PackedValue); + 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); + } - // Test values - Assert.Equal(11878, new HalfSingle(0.1F).PackedValue); - Assert.Equal(46285, new HalfSingle(-0.3F).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())); + } - // Test ordering - float x = .5F; - Assert.True(Equal(new Vector4(x, 0, 0, 1), new HalfSingle(x).ToVector4())); + [Fact] + public void NormalizedShort4_ToScaledVector4() + { + // arrange + var short4 = new NormalizedShort4(Vector4.One); - // Test ToScaledVector4. - Vector4 scaled = new HalfSingle(-1F).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); + // act + Vector4 actual = short4.ToScaledVector4(); - // Test PackFromScaledVector4. - var pixel = default(HalfSingle); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(48128, pixel.PackedValue); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort4_PackFromScaledVector4() + { + // arrange + var pixel = default(NormalizedShort4); + Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); + ulong expected = (ulong)0x7FFF7FFF7FFF7FFF; - new HalfSingle(x).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 0, 0)); + // act + pixel.PackFromScaledVector4(scaled); + ulong actual = pixel.PackedValue; - new HalfSingle(x).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 0, 0, 255)); + // assert + Assert.Equal(expected, actual); + } - new HalfSingle(x).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 0, 0)); + [Fact] + public void NormalizedShort4_ToRgb24() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 192); - new HalfSingle(x).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 0, 0, 255)); + // act + short4.ToRgb24(ref actual); - new HalfSingle(x).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 0, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void HalfVector2() + public void NormalizedShort4_ToRgba32() { - // Test PackedValue - Assert.Equal(0u, new HalfVector2(Vector2.Zero).PackedValue); - Assert.Equal(1006648320u, new HalfVector2(Vector2.One).PackedValue); - Assert.Equal(3033345638u, new HalfVector2(0.1f, -0.3f).PackedValue); - - // Test ToVector2 - Assert.True(Equal(Vector2.Zero, new HalfVector2(Vector2.Zero).ToVector2())); - Assert.True(Equal(Vector2.One, new HalfVector2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.UnitX, new HalfVector2(Vector2.UnitX).ToVector2())); - Assert.True(Equal(Vector2.UnitY, new HalfVector2(Vector2.UnitY).ToVector2())); - - // Test ToScaledVector4. - Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4(); - Assert.Equal(1F, scaled.X); - Assert.Equal(1F, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 192, 39); - // Test PackFromScaledVector4. - var pixel = default(HalfVector2); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(1006648320u, pixel.PackedValue); + // act + short4.ToRgba32(ref actual); - // Test ordering - float x = .5F; - float y = .25F; - Assert.True(Equal(new Vector4(x, y, 0, 1), new HalfVector2(x, y).ToVector4())); + // assert + Assert.Equal(expected, actual); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort4_ToBgr24() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 192); - new HalfVector2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 64, 0)); + // act + short4.ToBgr24(ref actual); - new HalfVector2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 64, 0, 255)); + // assert + Assert.Equal(expected, actual); + } - new HalfVector2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 64, 0)); + [Fact] + public void NormalizedShort4_ToArgb32() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 192, 39); - new HalfVector2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 64, 0, 255)); + // act + short4.ToArgb32(ref actual); - new HalfVector2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 64, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void HalfVector4() + public void NormalizedShort4_PackFromRgba32_ToRgba32() { - // Test PackedValue - Assert.Equal(0uL, new HalfVector4(Vector4.Zero).PackedValue); - Assert.Equal(4323521613979991040uL, new HalfVector4(Vector4.One).PackedValue); - Assert.Equal(13547034390470638592uL, new HalfVector4(-Vector4.One).PackedValue); - Assert.Equal(15360uL, new HalfVector4(Vector4.UnitX).PackedValue); - Assert.Equal(1006632960uL, new HalfVector4(Vector4.UnitY).PackedValue); - Assert.Equal(65970697666560uL, new HalfVector4(Vector4.UnitZ).PackedValue); - Assert.Equal(4323455642275676160uL, new HalfVector4(Vector4.UnitW).PackedValue); - Assert.Equal(4035285078724390502uL, new HalfVector4(0.1f, 0.3f, 0.4f, 0.5f).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new HalfVector4(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new HalfVector4(Vector4.One).ToVector4())); - Assert.True(Equal(-Vector4.One, new HalfVector4(-Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new HalfVector4(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new HalfVector4(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new HalfVector4(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new HalfVector4(Vector4.UnitW).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(0, scaled.W); + // arrange + var short4 = default(NormalizedShort4); + var expected = new Rgba32(9, 115, 202, 127); + var actual = default(Rgba32); - // Test PackFromScaledVector4. - var pixel = default(HalfVector4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(13547034390470638592uL, pixel.PackedValue); + // act + short4.PackFromRgba32(expected); + short4.ToRgba32(ref actual); - // Test ordering - float x = .25F; - float y = .5F; - float z = .75F; - float w = 1F; + // assert + Assert.Equal(expected, actual); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort4_PackFromBgra32_ToRgba32() + { + // arrange + var short4 = default(NormalizedShort4); + var actual = default(Bgra32); + var expected = new Bgra32(9, 115, 202, 127); - new HalfVector4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(64, 128, 191)); + // act + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); - new HalfVector4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(64, 128, 191, 255)); + // assert + Assert.Equal(expected, actual); + } - new HalfVector4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(64, 128, 191)); + [Fact] + public void NormalizedShort4_PackFromArgb32_ToRgba32() + { + // arrange + var short4 = default(NormalizedShort4); + var actual = default(Argb32); + var expected = new Argb32(9, 115, 202, 127); - new HalfVector4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(64, 128, 191, 255)); + // act + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); - new HalfVector4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(64, 128, 191, 255)); + // assert + Assert.Equal(expected, actual); + } - var r = default(HalfVector4); - r.PackFromRgba32(new Rgba32(64, 128, 191, 255)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(64, 128, 191, 255)); + [Fact] + public void Rg32_PackedValues() + { + float x = 0xb6dc; + float y = 0xA59f; + Assert.Equal(0xa59fb6dc, new Rg32(x / 0xffff, y / 0xffff).PackedValue); + Assert.Equal((uint)6554, new Rg32(0.1f, -0.3f).PackedValue); - r = default(HalfVector4); - r.PackFromBgra32(new Bgra32(64, 128, 191, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(64, 128, 191, 255)); + // Test the limits. + Assert.Equal((uint)0x0, new Rg32(Vector2.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rg32(Vector2.One).PackedValue); + } - r = default(HalfVector4); - r.PackFromArgb32(new Argb32(64, 128, 191, 255)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(64, 128, 191, 255)); + [Fact] + public void Rg32_ToVector2() + { + Assert.Equal(Vector2.Zero, new Rg32(Vector2.Zero).ToVector2()); + Assert.Equal(Vector2.One, new Rg32(Vector2.One).ToVector2()); } [Fact] - public void NormalizedByte2() + public void Rg32_ToScaledVector4() { - // Test PackedValue - Assert.Equal(0x0, new NormalizedByte2(Vector2.Zero).PackedValue); - Assert.Equal(0x7F7F, new NormalizedByte2(Vector2.One).PackedValue); - Assert.Equal(0x8181, new NormalizedByte2(-Vector2.One).PackedValue); + // arrange + var rg32 = new Rg32(Vector2.One); - // Test ToVector2 - Assert.True(Equal(Vector2.One, new NormalizedByte2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.Zero, new NormalizedByte2(Vector2.Zero).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedByte2(-Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.One, new NormalizedByte2(Vector2.One * 1234.0f).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedByte2(Vector2.One * -1234.0f).ToVector2())); + // act + Vector4 actual = rg32.ToScaledVector4(); - // Test ToVector4 - Assert.True(Equal(new Vector4(1, 1, 0, 1), new NormalizedByte2(Vector2.One).ToVector4())); - Assert.True(Equal(new Vector4(0, 0, 0, 1), new NormalizedByte2(Vector2.Zero).ToVector4())); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } - // Test ToScaledVector4. - Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1F, scaled.W); + [Fact] + public void Rg32_PackFromScaledVector4() + { + // arrange + var rg32 = new Rg32(Vector2.One); + var pixel = default(Rg32); + uint expected = 0xFFFFFFFF; - // Test PackFromScaledVector4. - var pixel = default(NormalizedByte2); + // act + Vector4 scaled = rg32.ToScaledVector4(); pixel.PackFromScaledVector4(scaled); - Assert.Equal(0x8181, pixel.PackedValue); - - // Test Ordering - float x = 0.1f; - float y = -0.3f; - Assert.Equal(0xda0d, new NormalizedByte2(x, y).PackedValue); - var n = new NormalizedByte2(); - n.PackFromRgba32(new Rgba32(141, 90, 0, 0)); - Assert.Equal(0xda0d, n.PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + uint actual = pixel.PackedValue; - new NormalizedByte2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 0)); + // assert + Assert.Equal(expected, actual); + } - new NormalizedByte2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 0, 255)); + [Fact] + public void Rg32_Clamping() + { + Assert.True(Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2())); + Assert.True(Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2())); + } - new NormalizedByte2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(141, 90, 0)); + [Fact] + public void Rg32_ToRgb24() + { + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 0); - new NormalizedByte2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 0, 255)); + // act + rg32.ToRgb24(ref actual); - new NormalizedByte2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackedValues() + public void Rg32_ToRgba32() { - Assert.Equal(0xA740DA0D, new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); - Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); - Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); - Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); - Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 0, 255); + + // act + rg32.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToVector4() + public void Rg32_ToBgr24() { - Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4())); + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 0); + + // act + rg32.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToScaledVector4() + public void Rg32_ToArgb32() { // arrange - var short4 = new NormalizedByte4(-Vector4.One); + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(25, 0, 0, 255); // act - Vector4 scaled = short4.ToScaledVector4(); + rg32.ToArgb32(ref actual); // assert - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(0, scaled.W); + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_PackedValue() + { + float x = 0x2db; + float y = 0x36d; + float z = 0x3b7; + float w = 0x1; + Assert.Equal((uint)0x7B7DB6DB, new Rgba1010102(x / 0x3ff, y / 0x3ff, z / 0x3ff, w / 3).PackedValue); + + Assert.Equal((uint)536871014, new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + + // Test the limits. + Assert.Equal((uint)0x0, new Rgba1010102(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rgba1010102(Vector4.One).PackedValue); + } + + [Fact] + public void Rgba1010102_ToVector4() + { + Assert.Equal(Vector4.Zero, new Rgba1010102(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new Rgba1010102(Vector4.One).ToVector4()); } [Fact] - public void NormalizedByte4_PackFromScaledVector4() + public void Rgba1010102_ToScaledVector4() { // arrange - var pixel = default(NormalizedByte4); - Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); + var rgba = new Rgba1010102(Vector4.One); - // act - pixel.PackFromScaledVector4(scaled); + // act + Vector4 actual = rgba.ToScaledVector4(); // assert - var expectedPackedValue = 0x81818181; - Assert.Equal(expectedPackedValue, pixel.PackedValue); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] - public void NormalizedByte4_ToRgb24() + public void Rgba1010102_PackFromScaledVector4() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var rgb24 = default(Rgb24); + var rgba = new Rgba1010102(Vector4.One); + var actual = default(Rgba1010102); + uint expected = 0xFFFFFFFF; // act - short4.ToRgb24(ref rgb24); + Vector4 scaled = rgba.ToScaledVector4(); + actual.PackFromScaledVector4(scaled); // assert - var expectedRgb24 = new Rgb24(141, 90, 192); - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual.PackedValue); } [Fact] - public void NormalizedByte4_ToRgba32() + public void Rgba1010102_Clamping() + { + Assert.True(Equal(Vector4.Zero, new Rgba1010102(Vector4.One * -1234.0f).ToVector4())); + Assert.True(Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4())); + } + + [Fact] + public void Rgba1010102_ToRgb24() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var rgba32 = default(Rgba32); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 128); // act - short4.ToRgba32(ref rgba32); + rgba.ToRgb24(ref actual); // assert - var expectedRgba32 = new Rgba32(141, 90, 192, 39); - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToBgr24() + public void Rgba1010102_ToRgba32() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var bgr24 = default(Bgr24); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 128, 0); // act - short4.ToBgr24(ref bgr24); + rgba.ToRgba32(ref actual); // assert - var expectedBgr24 = new Bgr24(141, 90, 192); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToArgb32() + public void Rgba1010102_ToBgr24() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var argb32 = default(Argb32); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 128); // act - short4.ToArgb32(ref argb32); + rgba.ToBgr24(ref actual); // assert - var expectedArgb32 = new Argb32(141, 90, 192, 39); - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackFromRgba32_ToRgba32() + public void Rgba1010102_ToBgra32() { // arrange - var rgba32 = default(Rgba32); - var short4 = default(NormalizedByte4); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(25, 0, 128, 0); - // act - short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); - short4.ToRgba32(ref rgba32); + // act + rgba.ToBgra32(ref actual); // assert - var expectedRgba32 = new Rgba32(9, 115, 202, 127); - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackFromBgra32_ToRgba32() + public void Rgba1010102_PackFromRgba32_ToRgba32() { // arrange - var bgra32 = default(Bgra32); - var short4 = default(NormalizedByte4); - var expectedBgra32 = new Bgra32(9, 115, 202, 127); + var rgba = default(Rgba1010102); + var expected = new Rgba32(25, 0, 128, 0); + var actual = default(Rgba32); - // act - short4.PackFromBgra32(expectedBgra32); - short4.ToBgra32(ref bgra32); + // act + rgba.PackFromRgba32(expected); + rgba.ToRgba32(ref actual); // assert - Assert.Equal(bgra32, expectedBgra32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackFromArgb32_ToRgba32() + public void Rgba1010102_PackFromBgra32_ToBgra32() { // arrange - var argb32 = default(Argb32); - var short4 = default(NormalizedByte4); + var rgba = default(Rgba1010102); + var expected = new Bgra32(25, 0, 128, 0); + var actual = default(Bgra32); - // act - short4.PackFromArgb32(new Argb32(9, 115, 202, 127)); - short4.ToArgb32(ref argb32); + // act + rgba.PackFromBgra32(expected); + rgba.ToBgra32(ref actual); // assert - var expectedArgb32 = new Argb32(9, 115, 202, 127); - Assert.Equal(argb32, expectedArgb32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort2() + public void Rgba1010102_PackFromArgb32_ToArgb32() { - Assert.Equal((uint)0x0, new NormalizedShort2(Vector2.Zero).PackedValue); - Assert.Equal((uint)0x7FFF7FFF, new NormalizedShort2(Vector2.One).PackedValue); - Assert.Equal(0x80018001, new NormalizedShort2(-Vector2.One).PackedValue); - - Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.Zero, new NormalizedShort2(Vector2.Zero).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedShort2(-Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One * 1234.0f).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedShort2(Vector2.One * -1234.0f).ToVector2())); - - Assert.True(Equal(new Vector4(1, 1, 0, 1), (new NormalizedShort2(Vector2.One)).ToVector4())); - Assert.True(Equal(new Vector4(0, 0, 0, 1), (new NormalizedShort2(Vector2.Zero)).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(NormalizedShort2); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0x80018001, pixel.PackedValue); - - // Test Ordering - float x = 0.35f; - float y = -0.2f; - Assert.Equal(0xE6672CCC, new NormalizedShort2(x, y).PackedValue); - x = 0.1f; - y = -0.3f; - Assert.Equal(3650751693, new NormalizedShort2(x, y).PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - var n = new NormalizedShort2(); - n.PackFromRgba32(new Rgba32(141, 90, 0, 0)); - n.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 0)); - - // TODO: I don't think this can ever pass since the bytes are already truncated. - // Assert.Equal(3650751693, n.PackedValue); - - new NormalizedShort2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 0)); - - new NormalizedShort2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 0, 255)); - - new NormalizedShort2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(141, 90, 0)); + // arrange + var rgba = default(Rgba1010102); + var expected = new Argb32(25, 0, 128, 0); + var actual = default(Argb32); - new NormalizedShort2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 0, 255)); + // act + rgba.PackFromArgb32(expected); + rgba.ToArgb32(ref actual); - new NormalizedShort2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackedValues() + public void Rgba32_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); + Assert.Equal(0x80001Au, new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); + // Test the limits. + Assert.Equal((uint)0x0, new Rgba32(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rgba32(Vector4.One).PackedValue); } [Fact] - public void NormalizedShort4_ToVector4() + public void Rgba32_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())); + Assert.True(Equal(Vector4.One, new Rgba32(Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.Zero, new Rgba32(Vector4.Zero).ToVector4())); + Assert.True(Equal(Vector4.UnitX, new Rgba32(Vector4.UnitX).ToVector4())); + Assert.True(Equal(Vector4.UnitY, new Rgba32(Vector4.UnitY).ToVector4())); + Assert.True(Equal(Vector4.UnitZ, new Rgba32(Vector4.UnitZ).ToVector4())); + Assert.True(Equal(Vector4.UnitW, new Rgba32(Vector4.UnitW).ToVector4())); } [Fact] - public void NormalizedShort4_ToScaledVector4() + public void Rgba32_ToScaledVector4() { // arrange - var short4 = new NormalizedShort4(Vector4.One); + var rgba = new Rgba32(Vector4.One); // act - Vector4 scaled = short4.ToScaledVector4(); + Vector4 actual = rgba.ToScaledVector4(); // assert - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] - public void NormalizedShort4_PackFromScaledVector4() + public void Rgba32_PackFromScaledVector4() { // arrange - var pixel = default(NormalizedShort4); - Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); + var rgba = new Rgba32(Vector4.One); + var actual = default(Rgba32); + uint expected = 0xFFFFFFFF; - // act - pixel.PackFromScaledVector4(scaled); + // act + Vector4 scaled = rgba.ToScaledVector4(); + actual.PackFromScaledVector4(scaled); // assert - var expectedPackedValue = (ulong)0x7FFF7FFF7FFF7FFF; - Assert.Equal(expectedPackedValue, pixel.PackedValue); + Assert.Equal(expected, actual.PackedValue); } [Fact] - public void NormalizedShort4_ToRgb24() + public void Rgba32_Clamping() + { + Assert.Equal(Vector4.Zero, new Rgba32(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Rgba32(Vector4.One * +1234.0f).ToVector4()); + } + + [Fact] + public void Rgba32_ToRgb24() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var rgb24 = default(Rgb24); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(0x1a, 0, 0x80); // act - short4.ToRgb24(ref rgb24); + rgba.ToRgb24(ref actual); // assert - var expectedRgb24 = new Rgb24(141, 90, 192); - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_ToRgba32() + public void Rgba32_ToRgba32() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var rgba32 = default(Rgba32); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); // act - short4.ToRgba32(ref rgba32); + rgba.ToRgba32(ref actual); // assert - var expectedRgba32 = new Rgba32(141, 90, 192, 39); - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_ToBgr24() + public void Rgba32_ToBgr24() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var bgr24 = default(Bgr24); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(0x1a, 0, 0x80); // act - short4.ToBgr24(ref bgr24); + rgba.ToBgr24(ref actual); // assert - var expectedBgr24 = new Bgr24(141, 90, 192); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_ToArgb32() + public void Rgba32_ToBgra32() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var argb32 = default(Argb32); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); // act - short4.ToArgb32(ref argb32); + rgba.ToBgra32(ref actual); // assert - var expectedArgb32 = new Argb32(141, 90, 192, 39); - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackFromRgba32_ToRgba32() + public void Rgba32_ToArgb32() { // arrange - var rgba32 = default(Rgba32); - var short4 = default(NormalizedShort4); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - // act - short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); - short4.ToRgba32(ref rgba32); + // act + rgba.ToArgb32(ref actual); // assert - var expectedRgba32 = new Rgba32(9, 115, 202, 127); - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackFromBgra32_ToRgba32() + public void Rgba32_PackFromRgba32_ToRgba32() { // arrange - var bgra32 = default(Bgra32); - var short4 = default(NormalizedShort4); + var rgba = default(Rgba32); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); // act - short4.PackFromBgra32(new Bgra32(9, 115, 202, 127)); - short4.ToBgra32(ref bgra32); + rgba.PackFromRgba32(expected); + rgba.ToRgba32(ref actual); // assert - var expectedBgra32 = new Bgra32(9, 115, 202, 127); - Assert.Equal(bgra32, expectedBgra32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackFromArgb32_ToRgba32() + public void Rgba32_PackFromBgra32_ToRgba32() { // arrange - var argb32 = default(Argb32); - var short4 = default(NormalizedShort4); + var rgba = default(Rgba32); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); // act - short4.PackFromArgb32(new Argb32(9, 115, 202, 127)); - short4.ToArgb32(ref argb32); + rgba.PackFromBgra32(expected); + rgba.ToBgra32(ref actual); // assert - var expectedArgb32 = new Argb32(9, 115, 202, 127); - Assert.Equal(argb32, expectedArgb32); + Assert.Equal(expected, actual); } [Fact] - public void Rg32() + public void Rgba32_PackFromArgb32_ToArgb32() { - // Test the limits. - Assert.Equal((uint)0x0, new Rg32(Vector2.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rg32(Vector2.One).PackedValue); - - // Test ToVector2 - Assert.True(Equal(Vector2.Zero, new Rg32(Vector2.Zero).ToVector2())); - Assert.True(Equal(Vector2.One, new Rg32(Vector2.One).ToVector2())); - - // Test ToScaledVector4. - Vector4 scaled = new Rg32(Vector2.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(Rg32); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); - - // Test clamping. - Assert.True(Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2())); - Assert.True(Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2())); - - // Test Ordering - float x = 0xb6dc; - float y = 0xA59f; - Assert.Equal(0xa59fb6dc, new Rg32(x / 0xffff, y / 0xffff).PackedValue); - x = 0.1f; - y = -0.3f; - Assert.Equal((uint)6554, new Rg32(x, y).PackedValue); - - // Test ordering - var rgb = default(Rgb24); + // arrange var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Rg32(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(25, 0, 0)); - - new Rg32(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 0, 255)); - - new Rg32(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(25, 0, 0)); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - new Rg32(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 0, 255)); + // act + rgba.PackFromArgb32(expected); + rgba.ToArgb32(ref actual); - new Rg32(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Rgba1010102() + public void Rgba64_PackedValues() { + Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(0.08f, 0.15f, 0.30f, 0.45f).PackedValue); // Test the limits. - Assert.Equal((uint)0x0, new Rgba1010102(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rgba1010102(Vector4.One).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Rgba1010102(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba1010102(Vector4.One).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new Rgba1010102(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(Rgba1010102); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); - - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Rgba1010102(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4())); - - // Test Ordering - float x = 0x2db; - float y = 0x36d; - float z = 0x3b7; - float w = 0x1; - Assert.Equal((uint)0x7B7DB6DB, new Rgba1010102(x / 0x3ff, y / 0x3ff, z / 0x3ff, w / 3).PackedValue); - x = 0.1f; - y = -0.3f; - z = 0.5f; - w = -0.7f; - Assert.Equal((uint)536871014, new Rgba1010102(x, y, z, w).PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Rgba1010102(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(25, 0, 128)); - - new Rgba1010102(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 128, 0)); - - new Rgba1010102(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(25, 0, 128)); + Assert.Equal((ulong)0x0, new Rgba64(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFFFFFFFFFF, new Rgba64(Vector4.One).PackedValue); + // Test data ordering + Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(((float)0x1EB8) / 0xffff, ((float)0x570A) / 0xffff, ((float)0x8F5C) / 0xffff, ((float)0xC7AD) / 0xffff).PackedValue); + Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(0.12f, 0.34f, 0.56f, 0.78f).PackedValue); + } - new Rgba1010102(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 128, 0)); + [Fact] + public void Rgba64_ToVector4() + { + Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.Zero).ToVector4())); + Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One).ToVector4())); + } - // Alpha component accuracy will be awful. - var r = default(Rgba1010102); - r.PackFromRgba32(new Rgba32(25, 0, 128, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 128, 0)); + [Fact] + public void Rgba64_ToScaledVector4() + { + // arrange + var short2 = new Rgba64(Vector4.One); - r = default(Rgba1010102); - r.PackFromBgra32(new Bgra32(25, 0, 128, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 128, 0)); + // act + Vector4 actual = short2.ToScaledVector4(); - r = default(Rgba1010102); - r.PackFromArgb32(new Argb32(25, 0, 128, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 128, 0)); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] - public void Rgba32() + public void Rgba64_PackFromScaledVector4() { - // Test the limits. - Assert.Equal((uint)0x0, new Rgba32(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rgba32(Vector4.One).PackedValue); - - // Test ToVector4. - Assert.True(Equal(Vector4.One, new Rgba32(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Rgba32(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new Rgba32(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new Rgba32(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new Rgba32(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new Rgba32(Vector4.UnitW).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new Rgba32(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // arrange + var pixel = default(Rgba64); + var short4 = new Rgba64(Vector4.One); + ulong expected = 0xFFFFFFFFFFFFFFFF; - // Test PackFromScaledVector4. - var pixel = default(Rgba32); + // act + Vector4 scaled = short4.ToScaledVector4(); pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); - - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Rgba32(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba32(Vector4.One * +1234.0f).ToVector4())); - - float x = +0.1f; - float y = -0.3f; - float z = +0.5f; - float w = -0.7f; - var rgba32 = new Rgba32(x, y, z, w); - Assert.Equal(0x80001Au, rgba32.PackedValue); - - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - rgba32.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80)); - - rgba32.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); - Assert.Equal(rgba, rgba.ToRgba32()); - - rgba32.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80)); + ulong actual = pixel.PackedValue; - rgba32.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - Assert.Equal(bgra, bgra.ToBgra32()); + // assert + Assert.Equal(expected, actual); + } - rgba32.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); - Assert.Equal(argb, argb.ToArgb32()); + [Fact] + public void Rgba64_Clamping() + { + Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.One * -1234.0f).ToVector4())); + Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One * 1234.0f).ToVector4())); + } - var r = default(Rgba32); - r.PackFromRgba32(new Rgba32(0x1a, 0, 0x80, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); + [Fact] + public void Rgba64_ToRgb24() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Rgb24); + var expected = new Rgb24(20, 38, 76); - r = default(Rgba32); - r.PackFromBgra32(new Bgra32(0x1a, 0, 0x80, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); + // act + rgba64.ToRgb24(ref actual); - r = default(Rgba32); - r.PackFromArgb32(new Argb32(0x1a, 0, 0x80, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Rgba64() + public void Rgba64_ToRgba32() { - // Test the limits. - Assert.Equal((ulong)0x0, new Rgba64(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFFFFFFFFFF, new Rgba64(Vector4.One).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One).ToVector4())); + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 76, 115); - // Test ToScaledVector4. - Vector4 scaled = new Rgba64(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // act + rgba64.ToRgba32(ref actual); - // Test PackFromScaledVector4. - var pixel = default(Rgba64); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFFFFFFFFFF, pixel.PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One * 1234.0f).ToVector4())); + [Fact] + public void Rgba64_ToBgr24() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Bgr24); + var expected = new Bgr24(20, 38, 76); - // Test data ordering - Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(((float)0x1EB8) / 0xffff, ((float)0x570A) / 0xffff, ((float)0x8F5C) / 0xffff, ((float)0xC7AD) / 0xffff).PackedValue); - Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(0.12f, 0.34f, 0.56f, 0.78f).PackedValue); + // act + rgba64.ToBgr24(ref actual); - float x = 0.08f; - float y = 0.15f; - float z = 0.30f; - float w = 0.45f; - Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(x, y, z, w).PackedValue); + // assert + Assert.Equal(expected, actual); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); + [Fact] + public void Rgba64_ToBgra32() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 76, 115); - new Rgba64(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(20, 38, 76)); + // act + rgba64.ToBgra32(ref actual); - new Rgba64(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 76, 115)); + // assert + Assert.Equal(expected, actual); + } - new Rgba64(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(20, 38, 76)); + [Fact] + public void Rgba64_PackFromRgba32_ToRgba32() + { + // arrange + var rgba64 = default(Rgba64); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 76, 115); - new Rgba64(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 76, 115)); + // act + rgba64.PackFromRgba32(expected); + rgba64.ToRgba32(ref actual); - var r = default(Rgba64); - r.PackFromRgba32(new Rgba32(20, 38, 76, 115)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 76, 115)); + // assert + Assert.Equal(expected, actual); } [Fact] @@ -1397,13 +2759,13 @@ namespace SixLabors.ImageSharp.Tests.Colors var short2 = new Short2(Vector2.One * 0x7FFF); // act - Vector4 scaled = short2.ToScaledVector4(); + Vector4 actual = short2.ToScaledVector4(); // assert - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); } [Fact] @@ -1412,14 +2774,15 @@ namespace SixLabors.ImageSharp.Tests.Colors // arrange var pixel = default(Short2); var short2 = new Short2(Vector2.One * 0x7FFF); - ulong expectedPackedValue = 0x7FFF7FFF; + ulong expected = 0x7FFF7FFF; // act Vector4 scaled = short2.ToScaledVector4(); pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; // assert - Assert.Equal(expectedPackedValue, pixel.PackedValue); + Assert.Equal(expected, actual); } [Fact] @@ -1427,14 +2790,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var rgb24 = default(Rgb24); - var expectedRgb24 = new Rgb24(128, 127, 0); + var actual = default(Rgb24); + var expected = new Rgb24(128, 127, 0); // act - short2.ToRgb24(ref rgb24); + short2.ToRgb24(ref actual); // assert - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual); } [Fact] @@ -1442,14 +2805,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var rgba32 = default(Rgba32); - var expectedRgba32 = new Rgba32(128, 127, 0, 255); + var actual = default(Rgba32); + var expected = new Rgba32(128, 127, 0, 255); // act - short2.ToRgba32(ref rgba32); + short2.ToRgba32(ref actual); // assert - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] @@ -1457,14 +2820,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var bgr24 = default(Bgr24); + var actual = default(Bgr24); + var expected = new Bgr24(128, 127, 0); // act - short2.ToBgr24(ref bgr24); + short2.ToBgr24(ref actual); // assert - var expectedBgr24 = new Bgr24(128, 127, 0); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] @@ -1472,14 +2835,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var argb32 = default(Argb32); - var expectedArgb32 = new Argb32(128, 127, 0, 255); + var actual = default(Argb32); + var expected = new Argb32(128, 127, 0, 255); // act - short2.ToArgb32(ref argb32); + short2.ToArgb32(ref actual); // assert - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] @@ -1487,30 +2850,30 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var bgra32 = default(Bgra32); - var expectedBgra32 = new Bgra32(128, 127, 0, 255); + var actual = default(Bgra32); + var expected = new Bgra32(128, 127, 0, 255); // act - short2.ToBgra32(ref bgra32); + short2.ToBgra32(ref actual); // assert - Assert.Equal(expectedBgra32, bgra32); + Assert.Equal(expected, actual); } [Fact] public void Short2_PackFromRgba32_ToRgba32() { // arrange - var rgba32 = default(Rgba32); var short2 = default(Short2); - var expectedRgba32 = new Rgba32(20, 38, 0, 255); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); // act - short2.PackFromRgba32(expectedRgba32); - short2.ToRgba32(ref rgba32); + short2.PackFromRgba32(expected); + short2.ToRgba32(ref actual); // assert - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] @@ -1519,10 +2882,8 @@ namespace SixLabors.ImageSharp.Tests.Colors var shortValue1 = new Short4(11547, 12653, 29623, 193); var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f); - ulong expectedPackedValue1 = 0x00c173b7316d2d1b; - ulong expectedPackedValue2 = 18446462598732840960; - Assert.Equal(expectedPackedValue1, shortValue1.PackedValue); - Assert.Equal(expectedPackedValue2, shortValue2.PackedValue); + Assert.Equal((ulong)0x00c173b7316d2d1b, shortValue1.PackedValue); + Assert.Equal(18446462598732840960, shortValue2.PackedValue); Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); @@ -1531,7 +2892,6 @@ namespace SixLabors.ImageSharp.Tests.Colors [Fact] public void Short4_ToVector4() { - // Test ToVector4. Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4()); Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4()); Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4()); @@ -1544,41 +2904,39 @@ namespace SixLabors.ImageSharp.Tests.Colors [Fact] public void Short4_ToScaledVector4() { - // Test ToScaledVector4. // arrange var short4 = new Short4(Vector4.One * 0x7FFF); // act - Vector4 scaled = short4.ToScaledVector4(); + Vector4 actual = short4.ToScaledVector4(); // assert - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] public void Short4_PackFromScaledVector4() { - // Test PackFromScaledVector4. // arrange var short4 = new Short4(Vector4.One * 0x7FFF); Vector4 scaled = short4.ToScaledVector4(); + long expected = 0x7FFF7FFF7FFF7FFF; // act var pixel = default(Short4); pixel.PackFromScaledVector4(scaled); + ulong actual = pixel.PackedValue; // assert - long expectedPackedValue = 0x7FFF7FFF7FFF7FFF; - Assert.Equal((ulong)expectedPackedValue, pixel.PackedValue); + Assert.Equal((ulong)expected, pixel.PackedValue); } [Fact] public void Short4_Clamping() { - // Test clamping. // arrange var short1 = new Short4(Vector4.One * 1234567.0f); var short2 = new Short4(Vector4.One * -1234567.0f); @@ -1597,14 +2955,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var rgb24 = default(Rgb24); + var actual = default(Rgb24); + var expected = new Rgb24(172, 177, 243); // act - shortValue.ToRgb24(ref rgb24); + shortValue.ToRgb24(ref actual); // assert - var expectedRgb24 = new Rgb24(172, 177, 243); - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual); } [Fact] @@ -1612,14 +2970,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var bgr24 = default(Bgr24); + var actual = default(Bgr24); + var expected = new Bgr24(172, 177, 243); // act - shortValue.ToBgr24(ref bgr24); + shortValue.ToBgr24(ref actual); // assert - var expectedBgr24 = new Bgr24(172, 177, 243); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] @@ -1627,14 +2985,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var rgba32 = default(Rgba32); + var actual = default(Rgba32); + var expected = new Rgba32(172, 177, 243, 128); // act - shortValue.ToRgba32(ref rgba32); + shortValue.ToRgba32(ref actual); // assert - var expectedRgba32 = new Rgba32(172, 177, 243, 128); - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] @@ -1642,14 +3000,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var bgra32 = default(Bgra32); + var actual = default(Bgra32); + var expected = new Bgra32(172, 177, 243, 128); // act - shortValue.ToBgra32(ref bgra32); + shortValue.ToBgra32(ref actual); // assert - var expectedBgra32 = new Bgra32(172, 177, 243, 128); - Assert.Equal(expectedBgra32, bgra32); + Assert.Equal(expected, actual); } [Fact] @@ -1657,62 +3015,62 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var argb32 = default(Argb32); + var actual = default(Argb32); + var expected = new Argb32(172, 177, 243, 128); // act - shortValue.ToArgb32(ref argb32); + shortValue.ToArgb32(ref actual); // assert - var expectedArgb32 = new Argb32(172, 177, 243, 128); - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] public void Short4_PackFromRgba32_ToRgba32() { // arrange - var rgba32 = default(Rgba32); var short4 = default(Short4); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); // act - short4.PackFromRgba32(new Rgba32(20, 38, 0, 255)); - short4.ToRgba32(ref rgba32); + short4.PackFromRgba32(expected); + short4.ToRgba32(ref actual); // assert - var expectedRgba32 = new Rgba32(20, 38, 0, 255); - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] public void Short4_PackFromBgra32_ToRgba32() { // arrange - var bgra32 = default(Bgra32); var short4 = default(Short4); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 0, 255); // act - short4.PackFromBgra32(new Bgra32(20, 38, 0, 255)); - short4.ToBgra32(ref bgra32); + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); // assert - var expectedBgra32 = new Bgra32(20, 38, 0, 255); - Assert.Equal(bgra32, expectedBgra32); + Assert.Equal(expected, actual); } [Fact] public void Short4_PackFromArgb32_ToRgba32() { // arrange - var argb32 = default(Argb32); var short4 = default(Short4); + var actual = default(Argb32); + var expected = new Argb32(20, 38, 0, 255); // act - short4.PackFromArgb32(new Argb32(20, 38, 0, 255)); - short4.ToArgb32(ref argb32); + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); // assert - var expectedArgb32 = new Argb32(20, 38, 0, 255); - Assert.Equal(argb32, expectedArgb32); + Assert.Equal(expected, actual); } // Comparison helpers with small tolerance to allow for floating point rounding during computations. From 5afcca6c6a0aee3e92d05401a8c644453c2e2447 Mon Sep 17 00:00:00 2001 From: popow Date: Sat, 2 Jun 2018 19:14:28 +0200 Subject: [PATCH 11/17] marked the asserts which fail --- tests/ImageSharp.Tests/Issues/Issue594.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/ImageSharp.Tests/Issues/Issue594.cs b/tests/ImageSharp.Tests/Issues/Issue594.cs index 73be612c1..81fd59885 100644 --- a/tests/ImageSharp.Tests/Issues/Issue594.cs +++ b/tests/ImageSharp.Tests/Issues/Issue594.cs @@ -64,7 +64,7 @@ namespace SixLabors.ImageSharp.Tests.Issues Assert.Equal(bgr, new Bgr24(141, 90, 192)); new NormalizedByte4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 192, 39)); + Assert.Equal(bgra, new Bgra32(141, 90, 192, 39)); // this assert fails in Release build on linux (#594) new NormalizedByte4(x, y, z, w).ToArgb32(ref argb); Assert.Equal(argb, new Argb32(141, 90, 192, 39)); @@ -137,7 +137,7 @@ namespace SixLabors.ImageSharp.Tests.Issues Assert.Equal(rgb, new Rgb24(141, 90, 192)); new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); + Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); // this assert fails in Release build on linux (#594) new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr); Assert.Equal(bgr, new Bgr24(141, 90, 192)); @@ -219,7 +219,7 @@ namespace SixLabors.ImageSharp.Tests.Issues var argb = default(Argb32); new Short4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(172, 177, 243)); // this seems to be causing the problem #594 + Assert.Equal(rgb, new Rgb24(172, 177, 243)); // this assert fails in Release build on linux (#594) new Short4(x, y, z, w).ToRgba32(ref rgba); Assert.Equal(rgba, new Rgba32(172, 177, 243, 128)); From def4aa127c59591e3a3731e0a2688dd0b040d27e Mon Sep 17 00:00:00 2001 From: popow Date: Sat, 2 Jun 2018 19:18:05 +0200 Subject: [PATCH 12/17] splitted up PackedPixelTests into one test file for each pixel format --- .../PixelFormats/Alpha8Tests.cs | 158 + .../PixelFormats/Argb32Tests.cs | 190 + .../PixelFormats/Bgr565Tests.cs | 145 + .../PixelFormats/Bgra4444Tests.cs | 194 ++ .../PixelFormats/Bgra5551Tests.cs | 193 + .../PixelFormats/Byte4Tests.cs | 191 + .../PixelFormats/HalfSingleTests.cs | 142 + .../PixelFormats/HalfVector2Tests.cs | 147 + .../PixelFormats/HalfVector4Tests.cs | 189 + .../PixelFormats/NormalizedByte2Tests.cs | 158 + .../PixelFormats/NormalizedByte4Tests.cs | 169 + .../PixelFormats/NormalizedShort2Tests.cs | 162 + .../PixelFormats/NormalizedShort4Tests.cs | 170 + .../PixelFormats/PackedPixelTests.cs | 3097 ----------------- .../PixelFormats/Rg32Tests.cs | 129 + .../PixelFormats/Rgba1010102Tests.cs | 179 + .../PixelFormats/Rgba32Tests.cs | 182 + .../PixelFormats/Rgba64Tests.cs | 144 + .../PixelFormats/Short2Tests.cs | 170 + .../PixelFormats/Short4Tests.cs | 206 ++ 20 files changed, 3218 insertions(+), 3097 deletions(-) create mode 100644 tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs delete mode 100644 tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs create mode 100644 tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs diff --git a/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs new file mode 100644 index 000000000..a0d4647fc --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs @@ -0,0 +1,158 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Alpha8Tests + { + [Fact] + public void Alpha8_PackedValue() + { + // Test the limits. + Assert.Equal(0x0, new Alpha8(0F).PackedValue); + Assert.Equal(0xFF, new Alpha8(1F).PackedValue); + + // Test clamping. + Assert.Equal(0x0, new Alpha8(-1234F).PackedValue); + Assert.Equal(0xFF, new Alpha8(1234F).PackedValue); + + // Test ordering + Assert.Equal(124, new Alpha8(124F / 0xFF).PackedValue); + Assert.Equal(26, new Alpha8(0.1F).PackedValue); + } + + [Fact] + public void Alpha8_ToVector4() + { + // arrange + var alpha = new Alpha8(.5F); + + // act + var actual = alpha.ToVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(.5F, actual.W, 2); + } + + [Fact] + public void Alpha8_ToScaledVector4() + { + // arrange + var alpha = new Alpha8(.5F); + + // act + Vector4 actual = alpha.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(.5F, actual.W, 2); + } + + [Fact] + public void Alpha8_PackFromScaledVector4() + { + // arrange + Alpha8 alpha = default; + int expected = 128; + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + byte actual = alpha.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToRgb24() + { + // arrange + Rgb24 actual = default; + Alpha8 alpha = default; + var expected = new Rgb24(0, 0, 0); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToRgba32() + { + // arrange + Rgba32 actual = default; + Alpha8 alpha = default; + var expected = new Rgba32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToBgr24() + { + // arrange + Bgr24 actual = default; + Alpha8 alpha = default; + var expected = new Bgr24(0, 0, 0); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToBgra32() + { + // arrange + Bgra32 actual = default; + Alpha8 alpha = default; + var expected = new Bgra32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToArgb32() + { + // arrange + Alpha8 alpha = default; + Argb32 actual = default; + var expected = new Argb32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs new file mode 100644 index 000000000..3cd7f72fa --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs @@ -0,0 +1,190 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Argb32Tests + { + [Fact] + public void Argb32_PackedValue() + { + Assert.Equal(0x80001a00u, new Argb32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); + Assert.Equal((uint)0x0, new Argb32(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Argb32(Vector4.One).PackedValue); + } + + [Fact] + public void Argb32_ToVector4() + { + Assert.Equal(Vector4.One, new Argb32(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new Argb32(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX, new Argb32(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new Argb32(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new Argb32(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new Argb32(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void Argb32_ToScaledVector4() + { + // arrange + var argb = new Argb32(Vector4.One); + + // act + Vector4 actual = argb.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Argb32_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4(); + var pixel = default(Argb32); + uint expected = 0xFFFFFFFF; + + // act + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_Clamping() + { + Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4()); + } + + [Fact] + public void Argb32_ToRgb24() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(0x1a, 0, 0x80); + + // act + argb.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_ToRgba32() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); + + // act + argb.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_ToBgr24() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(0x1a, 0, 0x80); + + // act + argb.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_ToBgra32() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); + + // act + argb.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_ToArgb32() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); + + // act + argb.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_PackFromRgba32_ToRgba32() + { + // arrange + var argb = default(Argb32); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); + + // act + argb.PackFromRgba32(expected); + argb.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_PackFromBgra32_ToBgra32() + { + // arrange + var argb = default(Argb32); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); + + // act + argb.PackFromBgra32(expected); + argb.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_PackFromArgb32_ToArgb32() + { + // arrange + var argb = default(Argb32); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); + + // act + argb.PackFromArgb32(expected); + argb.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs new file mode 100644 index 000000000..c4636e2ee --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs @@ -0,0 +1,145 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Bgr565Tests + { + [Fact] + public void Bgr565_PackedValue() + { + Assert.Equal(6160, new Bgr565(0.1F, -0.3F, 0.5F).PackedValue); + Assert.Equal(0x0, new Bgr565(Vector3.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgr565(Vector3.One).PackedValue); + // Make sure the swizzle is correct. + Assert.Equal(0xF800, new Bgr565(Vector3.UnitX).PackedValue); + Assert.Equal(0x07E0, new Bgr565(Vector3.UnitY).PackedValue); + Assert.Equal(0x001F, new Bgr565(Vector3.UnitZ).PackedValue); + } + + [Fact] + public void Bgr565_ToVector3() + { + Assert.Equal(Vector3.One, new Bgr565(Vector3.One).ToVector3()); + Assert.Equal(Vector3.Zero, new Bgr565(Vector3.Zero).ToVector3()); + Assert.Equal(Vector3.UnitX, new Bgr565(Vector3.UnitX).ToVector3()); + Assert.Equal(Vector3.UnitY, new Bgr565(Vector3.UnitY).ToVector3()); + Assert.Equal(Vector3.UnitZ, new Bgr565(Vector3.UnitZ).ToVector3()); + } + + [Fact] + public void Bgr565_ToScaledVector4() + { + // arrange + var bgr = new Bgr565(Vector3.One); + + // act + Vector4 actual = bgr.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Bgr565_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4(); + int expected = 0xFFFF; + var pixel = default(Bgr565); + + // act + pixel.PackFromScaledVector4(scaled); + ushort actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgr565_Clamping() + { + Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3()); + Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3()); + } + + [Fact] + public void Bgr565_ToRgb24() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 132); + + // act + bgra.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgr565_ToRgba32() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 132, 255); + + // act + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgr565_ToBgr24() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 132); + + // act + bgra.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgr565_ToBgra32() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Bgra32); + var expected = new Bgra32(25, 0, 132, 255); + + // act + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgr565_ToArgb32() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Argb32); + var expected = new Argb32(25, 0, 132, 255); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs new file mode 100644 index 000000000..3e208dc20 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs @@ -0,0 +1,194 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Bgra4444Tests + { + [Fact] + public void Bgra4444_PackedValue() + { + Assert.Equal(520, new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal(0x0, new Bgra4444(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgra4444(Vector4.One).PackedValue); + Assert.Equal(0x0F00, new Bgra4444(Vector4.UnitX).PackedValue); + Assert.Equal(0x00F0, new Bgra4444(Vector4.UnitY).PackedValue); + Assert.Equal(0x000F, new Bgra4444(Vector4.UnitZ).PackedValue); + Assert.Equal(0xF000, new Bgra4444(Vector4.UnitW).PackedValue); + } + + [Fact] + public void Bgra4444_ToVector4() + { + Assert.Equal(Vector4.One, new Bgra4444(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX, new Bgra4444(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new Bgra4444(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new Bgra4444(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new Bgra4444(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void Bgra4444_ToScaledVector4() + { + // arrange + var bgra = new Bgra4444(Vector4.One); + + // act + Vector4 actual = bgra.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Bgra4444_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4(); + int expected = 0xFFFF; + var bgra = default(Bgra4444); + + // act + bgra.PackFromScaledVector4(scaled); + ushort actual = bgra.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_Clamping() + { + Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Bgra4444_ToRgb24() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(34, 0, 136); + + // act + bgra.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToRgba32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(34, 0, 136, 0); + + // act + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToBgr24() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(34, 0, 136); + + // act + bgra.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToBgra32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(34, 0, 136, 0); + + // act + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToArgb32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(34, 0, 136, 0); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromRgba32_ToRgba32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Rgba32); + var expected = new Rgba32(34, 0, 136, 0); + + // act + bgra.PackFromRgba32(expected); + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromBgra32_ToBgra32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Bgra32); + var expected = new Bgra32(34, 0, 136, 0); + + // act + bgra.PackFromBgra32(expected); + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromArgb32_ToArgb32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Argb32); + var expected = new Argb32(34, 0, 136, 0); + + // act + bgra.PackFromArgb32(expected); + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs new file mode 100644 index 000000000..2ff9431f2 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs @@ -0,0 +1,193 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Bgra5551Tests + { + [Fact] + public void Bgra5551_PackedValue() + { + float x = 0x1a; + float y = 0x16; + float z = 0xd; + float w = 0x1; + Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue); + Assert.Equal(3088, new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + // Test the limits. + Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue); + } + + [Fact] + public void Bgra5551_ToVector4() + { + Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new Bgra5551(Vector4.One).ToVector4()); + } + + [Fact] + public void Bgra5551_ToScaledVector4() + { + // arrange + var bgra = new Bgra5551(Vector4.One); + + // act + Vector4 actual = bgra.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Bgra5551_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4(); + int expected = 0xFFFF; + var pixel = default(Bgra5551); + pixel.PackFromScaledVector4(scaled); + + // act + pixel.PackFromScaledVector4(scaled); + ushort actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Clamping() + { + Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Bgra5551_ToRgb24() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(24, 0, 131); + + // act + bgra.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Rgba32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(24, 0, 131, 0); + + // act + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_ToBgr24() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(24, 0, 131); + + // act + bgra.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Bgra32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(24, 0, 131, 0); + + // act + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_ToArgb32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(24, 0, 131, 0); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromRgba32_ToRgba32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Rgba32(24, 0, 131, 0); + var actual = default(Rgba32); + + // act + bgra.PackFromRgba32(expected); + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromBgra32_ToBgra32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Bgra32(24, 0, 131, 0); + var actual = default(Bgra32); + + // act + bgra.PackFromBgra32(expected); + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromArgb32_ToArgb32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Argb32(24, 0, 131, 0); + var actual = default(Argb32); + + // act + bgra.PackFromArgb32(expected); + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs new file mode 100644 index 000000000..6c221b0dc --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs @@ -0,0 +1,191 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Byte4Tests + { + [Fact] + public void Byte4_PackedValue() + { + Assert.Equal((uint)128, new Byte4(127.5f, -12.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((uint)0x1a7b362d, new Byte4(0x2d, 0x36, 0x7b, 0x1a).PackedValue); + Assert.Equal((uint)0x0, new Byte4(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Byte4(Vector4.One * 255).PackedValue); + } + + [Fact] + public void Byte4_ToVector4() + { + Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 255).ToVector4()); + Assert.Equal(Vector4.Zero, new Byte4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX * 255, new Byte4(Vector4.UnitX * 255).ToVector4()); + Assert.Equal(Vector4.UnitY * 255, new Byte4(Vector4.UnitY * 255).ToVector4()); + Assert.Equal(Vector4.UnitZ * 255, new Byte4(Vector4.UnitZ * 255).ToVector4()); + Assert.Equal(Vector4.UnitW * 255, new Byte4(Vector4.UnitW * 255).ToVector4()); + } + + [Fact] + public void Byte4_ToScaledVector4() + { + // arrange + var byte4 = new Byte4(Vector4.One * 255); + + // act + Vector4 actual = byte4.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Byte4_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4(); + var pixel = default(Byte4); + uint expected = 0xFFFFFFFF; + + // act + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Clamping() + { + Assert.Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Byte4_ToRgb24() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(128, 0, 0); + + // act + byte4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Rgba32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(128, 0, 0, 0); + + // act + byte4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_ToBgr24() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(128, 0, 0); + + // act + byte4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Bgra32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(128, 0, 0, 0); + + // act + byte4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Argb32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(128, 0, 0, 0); + + // act + byte4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromRgba32_ToRgba32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); + + // act + byte4.PackFromRgba32(expected); + byte4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromBgra32_ToBgra32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 0, 255); + + // act + byte4.PackFromBgra32(expected); + byte4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromArgb32_ToArgb32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Argb32); + var expected = new Argb32(20, 38, 0, 255); + + // act + byte4.PackFromArgb32(expected); + byte4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs new file mode 100644 index 000000000..e9705d23f --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs @@ -0,0 +1,142 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class HalfSingleTests + { + [Fact] + public void HalfSingle_PackedValue() + { + Assert.Equal(11878, new HalfSingle(0.1F).PackedValue); + Assert.Equal(46285, new HalfSingle(-0.3F).PackedValue); + + // Test limits + Assert.Equal(15360, new HalfSingle(1F).PackedValue); + Assert.Equal(0, new HalfSingle(0F).PackedValue); + Assert.Equal(48128, new HalfSingle(-1F).PackedValue); + } + + [Fact] + public void HalfSingle_ToVector4() + { + // arrange + var halfSingle = new HalfSingle(0.5f); + var expected = new Vector4(0.5f, 0, 0, 1); + + // act + var actual = halfSingle.ToVector4(); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToScaledVector4() + { + // arrange + var halfSingle = new HalfSingle(-1F); + + // act + Vector4 actual = halfSingle.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void HalfSingle_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new HalfSingle(-1F).ToScaledVector4(); + int expected = 48128; + var halfSingle = default(HalfSingle); + + // act + halfSingle.PackFromScaledVector4(scaled); + ushort actual = halfSingle.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToRgb24() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Rgb24); + var expected = new Rgb24(128, 0, 0); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Rgba32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Rgba32); + var expected = new Rgba32(128, 0, 0, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToBgr24() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Bgr24); + var expected = new Bgr24(128, 0, 0); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Bgra32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Bgra32); + var expected = new Bgra32(128, 0, 0, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Argb32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Argb32); + var expected = new Argb32(128, 0, 0, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs new file mode 100644 index 000000000..7adabc10c --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs @@ -0,0 +1,147 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class HalfVector2Tests + { + [Fact] + public void HalfVector2_PackedValue() + { + Assert.Equal(0u, new HalfVector2(Vector2.Zero).PackedValue); + Assert.Equal(1006648320u, new HalfVector2(Vector2.One).PackedValue); + Assert.Equal(3033345638u, new HalfVector2(0.1f, -0.3f).PackedValue); + } + + [Fact] + public void HalfVector2_ToVector2() + { + Assert.Equal(Vector2.Zero, new HalfVector2(Vector2.Zero).ToVector2()); + Assert.Equal(Vector2.One, new HalfVector2(Vector2.One).ToVector2()); + Assert.Equal(Vector2.UnitX, new HalfVector2(Vector2.UnitX).ToVector2()); + Assert.Equal(Vector2.UnitY, new HalfVector2(Vector2.UnitY).ToVector2()); + } + + [Fact] + public void HalfVector2_ToScaledVector4() + { + // arrange + var halfVector = new HalfVector2(Vector2.One); + + // act + Vector4 actual = halfVector.ToScaledVector4(); + + // assert + Assert.Equal(1F, actual.X); + Assert.Equal(1F, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void HalfVector2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4(); + uint expected = 1006648320u; + var halfVector = default(HalfVector2); + + // act + halfVector.PackFromScaledVector4(scaled); + uint actual = halfVector.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToVector4() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var expected = new Vector4(0.5f, .25F, 0, 1); + + // act + var actual = halfVector.ToVector4(); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToRgb24() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Rgb24); + var expected = new Rgb24(128, 64, 0); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Rgba32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Rgba32); + var expected = new Rgba32(128, 64, 0, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToBgr24() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Bgr24); + var expected = new Bgr24(128, 64, 0); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Bgra32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Bgra32); + var expected = new Bgra32(128, 64, 0, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Argb32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Argb32); + var expected = new Argb32(128, 64, 0, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs new file mode 100644 index 000000000..a0ddfabdf --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs @@ -0,0 +1,189 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class HalfVector4Tests + { + [Fact] + public void HalfVector4_PackedValue() + { + Assert.Equal(0uL, new HalfVector4(Vector4.Zero).PackedValue); + Assert.Equal(4323521613979991040uL, new HalfVector4(Vector4.One).PackedValue); + Assert.Equal(13547034390470638592uL, new HalfVector4(-Vector4.One).PackedValue); + Assert.Equal(15360uL, new HalfVector4(Vector4.UnitX).PackedValue); + Assert.Equal(1006632960uL, new HalfVector4(Vector4.UnitY).PackedValue); + Assert.Equal(65970697666560uL, new HalfVector4(Vector4.UnitZ).PackedValue); + Assert.Equal(4323455642275676160uL, new HalfVector4(Vector4.UnitW).PackedValue); + Assert.Equal(4035285078724390502uL, new HalfVector4(0.1f, 0.3f, 0.4f, 0.5f).PackedValue); + } + + [Fact] + public void HalfVector4_ToVector4() + { + Assert.Equal(Vector4.Zero, new HalfVector4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new HalfVector4(Vector4.One).ToVector4()); + Assert.Equal(-Vector4.One, new HalfVector4(-Vector4.One).ToVector4()); + Assert.Equal(Vector4.UnitX, new HalfVector4(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new HalfVector4(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new HalfVector4(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new HalfVector4(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void HalfVector4_ToScaledVector4() + { + // arrange + var halfVector4 = new HalfVector4(-Vector4.One); + + // act + Vector4 actual = halfVector4.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(0, actual.W); + } + + [Fact] + public void HalfVector4_PackFromScaledVector4() + { + // arrange + var halfVector4 = default(HalfVector4); + Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4(); + ulong expected = 13547034390470638592uL; + + // act + halfVector4.PackFromScaledVector4(scaled); + ulong actual = halfVector4.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_ToRgb24() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Rgb24); + var expected = new Rgb24(64, 128, 191); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Rgba32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Rgba32); + var expected = new Rgba32(64, 128, 191, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_ToBgr24() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Bgr24); + var expected = new Bgr24(64, 128, 191); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Bgra32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Bgra32); + var expected = new Bgra32(64, 128, 191, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Argb32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Argb32); + var expected = new Argb32(64, 128, 191, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromRgba32_ToRgba32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Rgba32); + var expected = new Rgba32(64, 128, 191, 255); + + // act + halVector.PackFromRgba32(expected); + halVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromBgra32_ToBgra32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Bgra32); + var expected = new Bgra32(64, 128, 191, 255); + + // act + halVector.PackFromBgra32(expected); + halVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromArgb32_ToArgb32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Argb32); + var expected = new Argb32(64, 128, 191, 255); + + // act + halVector.PackFromArgb32(expected); + halVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs new file mode 100644 index 000000000..b13f3d916 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs @@ -0,0 +1,158 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class NormalizedByte2Tests + { + [Fact] + public void NormalizedByte2_PackedValue() + { + Assert.Equal(0xda0d, new NormalizedByte2(0.1f, -0.3f).PackedValue); + Assert.Equal(0x0, new NormalizedByte2(Vector2.Zero).PackedValue); + Assert.Equal(0x7F7F, new NormalizedByte2(Vector2.One).PackedValue); + Assert.Equal(0x8181, new NormalizedByte2(-Vector2.One).PackedValue); + } + + [Fact] + public void NormalizedByte2_ToVector2() + { + Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One).ToVector2()); + Assert.Equal(Vector2.Zero, new NormalizedByte2(Vector2.Zero).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedByte2(-Vector2.One).ToVector2()); + Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One * 1234.0f).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedByte2(Vector2.One * -1234.0f).ToVector2()); + } + + [Fact] + public void NormalizedByte2_ToVector4() + { + Assert.Equal(new Vector4(1, 1, 0, 1), new NormalizedByte2(Vector2.One).ToVector4()); + Assert.Equal(new Vector4(0, 0, 0, 1), new NormalizedByte2(Vector2.Zero).ToVector4()); + } + + [Fact] + public void NormalizedByte2_ToScaledVector4() + { + // arrange + var byte2 = new NormalizedByte2(-Vector2.One); + + // act + Vector4 actual = byte2.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1F, actual.W); + } + + [Fact] + public void NormalizedByte2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4(); + var byte2 = default(NormalizedByte2); + uint expected = 0x8181; + + // act + byte2.PackFromScaledVector4(scaled); + uint actual = byte2.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_PackFromRgba32() + { + // arrange + var byte2 = new NormalizedByte2(); + var rgba = new Rgba32(141, 90, 0, 0); + int expected = 0xda0d; + + // act + byte2.PackFromRgba32(rgba); + ushort actual = byte2.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToRgb24() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 0); + + // act + short4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToRgba32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 0, 255); + + // act + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToBgr24() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 0); + + // act + short4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToBgra32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Bgra32); + var expected = new Bgra32(141, 90, 0, 255); + + // act + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToArgb32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 0, 255); + + // act + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs new file mode 100644 index 000000000..9b71bb72b --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs @@ -0,0 +1,169 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class NormalizedByte4Tests + { + [Fact] + public void NormalizedByte4_PackedValues() + { + Assert.Equal(0xA740DA0D, new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); + Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); + Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); + Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); + } + + [Fact] + public void NormalizedByte4_ToVector4() + { + Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4()); + Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4()); + } + + [Fact] + public void NormalizedByte4_ToScaledVector4() + { + // arrange + var short4 = new NormalizedByte4(-Vector4.One); + + // act + Vector4 actual = short4.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(0, actual.W); + } + + [Fact] + public void NormalizedByte4_PackFromScaledVector4() + { + // arrange + var pixel = default(NormalizedByte4); + Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); + uint expected = 0x81818181; + + // act + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToRgb24() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 192); + + // act + short4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToRgba32() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 192, 39); + + // act + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToBgr24() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 192); + + // act + short4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToArgb32() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 192, 39); + + // act + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromRgba32_ToRgba32() + { + // arrange + var short4 = default(NormalizedByte4); + var actual = default(Rgba32); + var expected = new Rgba32(9, 115, 202, 127); + + // act + short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromBgra32_ToRgba32() + { + // arrange + var actual = default(Bgra32); + var short4 = default(NormalizedByte4); + var expected = new Bgra32(9, 115, 202, 127); + + // act + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromArgb32_ToRgba32() + { + // arrange + var short4 = default(NormalizedByte4); + var actual = default(Argb32); + var expected = new Argb32(9, 115, 202, 127); + + // act + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs new file mode 100644 index 000000000..cf40badb4 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs @@ -0,0 +1,162 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class NormalizedShort2Tests + { + [Fact] + public void NormalizedShort2_PackedValue() + { + Assert.Equal(0xE6672CCC, new NormalizedShort2(0.35f, -0.2f).PackedValue); + Assert.Equal(3650751693, new NormalizedShort2(0.1f, -0.3f).PackedValue); + Assert.Equal((uint)0x0, new NormalizedShort2(Vector2.Zero).PackedValue); + Assert.Equal((uint)0x7FFF7FFF, new NormalizedShort2(Vector2.One).PackedValue); + Assert.Equal(0x80018001, new NormalizedShort2(-Vector2.One).PackedValue); + // TODO: I don't think this can ever pass since the bytes are already truncated. + // Assert.Equal(3650751693, n.PackedValue); + } + + [Fact] + public void NormalizedShort2_ToVector2() + { + Assert.Equal(Vector2.One, new NormalizedShort2(Vector2.One).ToVector2()); + Assert.Equal(Vector2.Zero, new NormalizedShort2(Vector2.Zero).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedShort2(-Vector2.One).ToVector2()); + Assert.Equal(Vector2.One, new NormalizedShort2(Vector2.One * 1234.0f).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedShort2(Vector2.One * -1234.0f).ToVector2()); + } + + [Fact] + public void NormalizedShort2_ToVector4() + { + Assert.Equal(new Vector4(1, 1, 0, 1), (new NormalizedShort2(Vector2.One)).ToVector4()); + Assert.Equal(new Vector4(0, 0, 0, 1), (new NormalizedShort2(Vector2.Zero)).ToVector4()); + } + + [Fact] + public void NormalizedShort2_ToScaledVector4() + { + // arrange + var short2 = new NormalizedShort2(-Vector2.One); + + // act + Vector4 actual = short2.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void NormalizedShort2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4(); + var short2 = default(NormalizedShort2); + uint expected = 0x80018001; + + // act + short2.PackFromScaledVector4(scaled); + uint actual = short2.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_PackFromRgba32_ToRgb24() + { + // arrange + var actual = default(Rgb24); + var short2 = new NormalizedShort2(); + var rgba = new Rgba32(141, 90, 0, 0); + var expected = new Rgb24(141, 90, 0); + + // act + short2.PackFromRgba32(rgba); + short2.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_ToRgb24() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 0); + + // act + short2.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_ToRgba32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 0, 255); + + // act + short2.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_ToBgr24() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 0); + + // act + short2.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_ToBgra32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Bgra32); + var expected = new Bgra32(141, 90, 0, 255); + + // act + short2.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_ToArgb32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 0, 255); + + // act + short2.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs new file mode 100644 index 000000000..ee6cabdaf --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs @@ -0,0 +1,170 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class NormalizedShort4Tests + { + [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.Equal(Vector4.One, new NormalizedShort4(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new NormalizedShort4(Vector4.Zero).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedShort4(-Vector4.One).ToVector4()); + Assert.Equal(Vector4.One, new NormalizedShort4(Vector4.One * 1234.0f).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedShort4(Vector4.One * -1234.0f).ToVector4()); + } + + [Fact] + public void NormalizedShort4_ToScaledVector4() + { + // arrange + var short4 = new NormalizedShort4(Vector4.One); + + // act + Vector4 actual = short4.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void NormalizedShort4_PackFromScaledVector4() + { + // arrange + var pixel = default(NormalizedShort4); + Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); + ulong expected = (ulong)0x7FFF7FFF7FFF7FFF; + + // act + pixel.PackFromScaledVector4(scaled); + ulong actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort4_ToRgb24() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 192); + + // act + short4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort4_ToRgba32() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 192, 39); + + // act + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort4_ToBgr24() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 192); + + // act + short4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort4_ToArgb32() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 192, 39); + + // act + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort4_PackFromRgba32_ToRgba32() + { + // arrange + var short4 = default(NormalizedShort4); + var expected = new Rgba32(9, 115, 202, 127); + var actual = default(Rgba32); + + // act + short4.PackFromRgba32(expected); + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort4_PackFromBgra32_ToRgba32() + { + // arrange + var short4 = default(NormalizedShort4); + var actual = default(Bgra32); + var expected = new Bgra32(9, 115, 202, 127); + + // act + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort4_PackFromArgb32_ToRgba32() + { + // arrange + var short4 = default(NormalizedShort4); + var actual = default(Argb32); + var expected = new Argb32(9, 115, 202, 127); + + // act + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs deleted file mode 100644 index cd0435c4a..000000000 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ /dev/null @@ -1,3097 +0,0 @@ -// 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; - -namespace SixLabors.ImageSharp.Tests.Colors -{ - /// - /// The packed pixel tests. - /// - /// - /// The "ToVector4" tests should now be covered in - /// and at some point they can be safely removed from here. - /// - public class PackedPixelTests - { - [Fact] - public void Alpha8_PackedValue() - { - // Test the limits. - Assert.Equal(0x0, new Alpha8(0F).PackedValue); - Assert.Equal(0xFF, new Alpha8(1F).PackedValue); - - // Test clamping. - Assert.Equal(0x0, new Alpha8(-1234F).PackedValue); - Assert.Equal(0xFF, new Alpha8(1234F).PackedValue); - - // Test ordering - Assert.Equal(124, new Alpha8(124F / 0xFF).PackedValue); - Assert.Equal(26, new Alpha8(0.1F).PackedValue); - } - - [Fact] - public void Alpha8_ToVector4() - { - // arrange - var alpha = new Alpha8(.5F); - - // act - var actual = alpha.ToVector4(); - - // assert - Assert.Equal(0, actual.X); - Assert.Equal(0, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(.5F, actual.W, 2); - } - - [Fact] - public void Alpha8_ToScaledVector4() - { - // arrange - var alpha = new Alpha8(.5F); - - // act - Vector4 actual = alpha.ToScaledVector4(); - - // assert - Assert.Equal(0, actual.X); - Assert.Equal(0, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(.5F, actual.W, 2); - } - - [Fact] - public void Alpha8_PackFromScaledVector4() - { - // arrange - Alpha8 alpha = default; - int expected = 128; - Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - - // act - alpha.PackFromScaledVector4(scaled); - byte actual = alpha.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Alpha8_PackFromScaledVector4_ToRgb24() - { - // arrange - Rgb24 actual = default; - Alpha8 alpha = default; - var expected = new Rgb24(0, 0, 0); - Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - - // act - alpha.PackFromScaledVector4(scaled); - alpha.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Alpha8_PackFromScaledVector4_ToRgba32() - { - // arrange - Rgba32 actual = default; - Alpha8 alpha = default; - var expected = new Rgba32(0, 0, 0, 128); - Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - - // act - alpha.PackFromScaledVector4(scaled); - alpha.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Alpha8_PackFromScaledVector4_ToBgr24() - { - // arrange - Bgr24 actual = default; - Alpha8 alpha = default; - var expected = new Bgr24(0, 0, 0); - Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - - // act - alpha.PackFromScaledVector4(scaled); - alpha.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Alpha8_PackFromScaledVector4_ToBgra32() - { - // arrange - Bgra32 actual = default; - Alpha8 alpha = default; - var expected = new Bgra32(0, 0, 0, 128); - Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - - // act - alpha.PackFromScaledVector4(scaled); - alpha.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Alpha8_PackFromScaledVector4_ToArgb32() - { - // arrange - Alpha8 alpha = default; - Argb32 actual = default; - var expected = new Argb32(0, 0, 0, 128); - Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - - // act - alpha.PackFromScaledVector4(scaled); - alpha.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_PackedValue() - { - Assert.Equal(0x80001a00u, new Argb32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); - Assert.Equal((uint)0x0, new Argb32(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Argb32(Vector4.One).PackedValue); - } - - [Fact] - public void Argb32_ToVector4() - { - Assert.Equal(Vector4.One, new Argb32(Vector4.One).ToVector4()); - Assert.Equal(Vector4.Zero, new Argb32(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.UnitX, new Argb32(Vector4.UnitX).ToVector4()); - Assert.Equal(Vector4.UnitY, new Argb32(Vector4.UnitY).ToVector4()); - Assert.Equal(Vector4.UnitZ, new Argb32(Vector4.UnitZ).ToVector4()); - Assert.Equal(Vector4.UnitW, new Argb32(Vector4.UnitW).ToVector4()); - } - - [Fact] - public void Argb32_ToScaledVector4() - { - // arrange - var argb = new Argb32(Vector4.One); - - // act - Vector4 actual = argb.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Argb32_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4(); - var pixel = default(Argb32); - uint expected = 0xFFFFFFFF; - - // act - pixel.PackFromScaledVector4(scaled); - uint actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_Clamping() - { - Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4()); - Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4()); - } - - [Fact] - public void Argb32_ToRgb24() - { - // arrange - var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(0x1a, 0, 0x80); - - // act - argb.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_ToRgba32() - { - // arrange - var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(0x1a, 0, 0x80, 0); - - // act - argb.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_ToBgr24() - { - // arrange - var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(0x1a, 0, 0x80); - - // act - argb.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_ToBgra32() - { - // arrange - var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Bgra32); - var expected = new Bgra32(0x1a, 0, 0x80, 0); - - // act - argb.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_ToArgb32() - { - // arrange - var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Argb32); - var expected = new Argb32(0x1a, 0, 0x80, 0); - - // act - argb.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_PackFromRgba32_ToRgba32() - { - // arrange - var argb = default(Argb32); - var actual = default(Rgba32); - var expected = new Rgba32(0x1a, 0, 0x80, 0); - - // act - argb.PackFromRgba32(expected); - argb.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_PackFromBgra32_ToBgra32() - { - // arrange - var argb = default(Argb32); - var actual = default(Bgra32); - var expected = new Bgra32(0x1a, 0, 0x80, 0); - - // act - argb.PackFromBgra32(expected); - argb.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Argb32_PackFromArgb32_ToArgb32() - { - // arrange - var argb = default(Argb32); - var actual = default(Argb32); - var expected = new Argb32(0x1a, 0, 0x80, 0); - - // act - argb.PackFromArgb32(expected); - argb.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgr565_PackedValue() - { - Assert.Equal(6160, new Bgr565(0.1F, -0.3F, 0.5F).PackedValue); - Assert.Equal(0x0, new Bgr565(Vector3.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgr565(Vector3.One).PackedValue); - // Make sure the swizzle is correct. - Assert.Equal(0xF800, new Bgr565(Vector3.UnitX).PackedValue); - Assert.Equal(0x07E0, new Bgr565(Vector3.UnitY).PackedValue); - Assert.Equal(0x001F, new Bgr565(Vector3.UnitZ).PackedValue); - } - - [Fact] - public void Bgr565_ToVector3() - { - Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One).ToVector3())); - Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.Zero).ToVector3())); - Assert.True(Equal(Vector3.UnitX, new Bgr565(Vector3.UnitX).ToVector3())); - Assert.True(Equal(Vector3.UnitY, new Bgr565(Vector3.UnitY).ToVector3())); - Assert.True(Equal(Vector3.UnitZ, new Bgr565(Vector3.UnitZ).ToVector3())); - } - - [Fact] - public void Bgr565_ToScaledVector4() - { - // arrange - var bgr = new Bgr565(Vector3.One); - - // act - Vector4 actual = bgr.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Bgr565_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4(); - int expected = 0xFFFF; - var pixel = default(Bgr565); - - // act - pixel.PackFromScaledVector4(scaled); - ushort actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgr565_Clamping() - { - Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3()); - Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3()); - } - - [Fact] - public void Bgr565_ToRgb24() - { - // arrange - var bgra = new Bgr565(0.1F, -0.3F, 0.5F); - var actual = default(Rgb24); - var expected = new Rgb24(25, 0, 132); - - // act - bgra.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgr565_ToRgba32() - { - // arrange - var bgra = new Bgr565(0.1F, -0.3F, 0.5F); - var actual = default(Rgba32); - var expected = new Rgba32(25, 0, 132, 255); - - // act - bgra.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgr565_ToBgr24() - { - // arrange - var bgra = new Bgr565(0.1F, -0.3F, 0.5F); - var actual = default(Bgr24); - var expected = new Bgr24(25, 0, 132); - - // act - bgra.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgr565_ToBgra32() - { - // arrange - var bgra = new Bgr565(0.1F, -0.3F, 0.5F); - var actual = default(Bgra32); - var expected = new Bgra32(25, 0, 132, 255); - - // act - bgra.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgr565_ToArgb32() - { - // arrange - var bgra = new Bgr565(0.1F, -0.3F, 0.5F); - var actual = default(Argb32); - var expected = new Argb32(25, 0, 132, 255); - - // act - bgra.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_PackedValue() - { - Assert.Equal(520, new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); - Assert.Equal(0x0, new Bgra4444(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgra4444(Vector4.One).PackedValue); - Assert.Equal(0x0F00, new Bgra4444(Vector4.UnitX).PackedValue); - Assert.Equal(0x00F0, new Bgra4444(Vector4.UnitY).PackedValue); - Assert.Equal(0x000F, new Bgra4444(Vector4.UnitZ).PackedValue); - Assert.Equal(0xF000, new Bgra4444(Vector4.UnitW).PackedValue); - } - - [Fact] - public void Bgra4444_ToVector4() - { - Assert.Equal(Vector4.One, new Bgra4444(Vector4.One).ToVector4()); - Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.UnitX, new Bgra4444(Vector4.UnitX).ToVector4()); - Assert.Equal(Vector4.UnitY, new Bgra4444(Vector4.UnitY).ToVector4()); - Assert.Equal(Vector4.UnitZ, new Bgra4444(Vector4.UnitZ).ToVector4()); - Assert.Equal(Vector4.UnitW, new Bgra4444(Vector4.UnitW).ToVector4()); - } - - [Fact] - public void Bgra4444_ToScaledVector4() - { - // arrange - var bgra = new Bgra4444(Vector4.One); - - // act - Vector4 actual = bgra.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Bgra4444_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4(); - int expected = 0xFFFF; - var bgra = default(Bgra4444); - - // act - bgra.PackFromScaledVector4(scaled); - ushort actual = bgra.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_Clamping() - { - Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4()); - Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4()); - } - - [Fact] - public void Bgra4444_ToRgb24() - { - // arrange - var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(34, 0, 136); - - // act - bgra.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_ToRgba32() - { - // arrange - var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(34, 0, 136, 0); - - // act - bgra.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_ToBgr24() - { - // arrange - var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(34, 0, 136); - - // act - bgra.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_ToBgra32() - { - // arrange - var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgra32); - var expected = new Bgra32(34, 0, 136, 0); - - // act - bgra.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_ToArgb32() - { - // arrange - var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Argb32); - var expected = new Argb32(34, 0, 136, 0); - - // act - bgra.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_PackFromRgba32_ToRgba32() - { - // arrange - var bgra = default(Bgra4444); - var actual = default(Rgba32); - var expected = new Rgba32(34, 0, 136, 0); - - // act - bgra.PackFromRgba32(expected); - bgra.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_PackFromBgra32_ToBgra32() - { - // arrange - var bgra = default(Bgra4444); - var actual = default(Bgra32); - var expected = new Bgra32(34, 0, 136, 0); - - // act - bgra.PackFromBgra32(expected); - bgra.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra4444_PackFromArgb32_ToArgb32() - { - // arrange - var bgra = default(Bgra4444); - var actual = default(Argb32); - var expected = new Argb32(34, 0, 136, 0); - - // act - bgra.PackFromArgb32(expected); - bgra.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_PackedValue() - { - float x = 0x1a; - float y = 0x16; - float z = 0xd; - float w = 0x1; - Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue); - Assert.Equal(3088, new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); - // Test the limits. - Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue); - } - - [Fact] - public void Bgra5551_ToVector4() - { - Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.One, new Bgra5551(Vector4.One).ToVector4()); - } - - [Fact] - public void Bgra5551_ToScaledVector4() - { - // arrange - var bgra = new Bgra5551(Vector4.One); - - // act - Vector4 actual = bgra.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Bgra5551_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4(); - int expected = 0xFFFF; - var pixel = default(Bgra5551); - pixel.PackFromScaledVector4(scaled); - - // act - pixel.PackFromScaledVector4(scaled); - ushort actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_Clamping() - { - Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); - Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); - } - - [Fact] - public void Bgra5551_ToRgb24() - { - // arrange - var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(24, 0, 131); - - // act - bgra.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_Rgba32() - { - // arrange - var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(24, 0, 131, 0); - - // act - bgra.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_ToBgr24() - { - // arrange - var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(24, 0, 131); - - // act - bgra.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_Bgra32() - { - // arrange - var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgra32); - var expected = new Bgra32(24, 0, 131, 0); - - // act - bgra.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_ToArgb32() - { - // arrange - var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Argb32); - var expected = new Argb32(24, 0, 131, 0); - - // act - bgra.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_PackFromRgba32_ToRgba32() - { - // arrange - var bgra = default(Bgra5551); - var expected = new Rgba32(24, 0, 131, 0); - var actual = default(Rgba32); - - // act - bgra.PackFromRgba32(expected); - bgra.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_PackFromBgra32_ToBgra32() - { - // arrange - var bgra = default(Bgra5551); - var expected = new Bgra32(24, 0, 131, 0); - var actual = default(Bgra32); - - // act - bgra.PackFromBgra32(expected); - bgra.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Bgra5551_PackFromArgb32_ToArgb32() - { - // arrange - var bgra = default(Bgra5551); - var expected = new Argb32(24, 0, 131, 0); - var actual = default(Argb32); - - // act - bgra.PackFromArgb32(expected); - bgra.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_PackedValue() - { - Assert.Equal((uint)128, new Byte4(127.5f, -12.3f, 0.5f, -0.7f).PackedValue); - Assert.Equal((uint)0x1a7b362d, new Byte4(0x2d, 0x36, 0x7b, 0x1a).PackedValue); - Assert.Equal((uint)0x0, new Byte4(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Byte4(Vector4.One * 255).PackedValue); - } - - [Fact] - public void Byte4_ToVector4() - { - Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 255).ToVector4()); - Assert.Equal(Vector4.Zero, new Byte4(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.UnitX * 255, new Byte4(Vector4.UnitX * 255).ToVector4()); - Assert.Equal(Vector4.UnitY * 255, new Byte4(Vector4.UnitY * 255).ToVector4()); - Assert.Equal(Vector4.UnitZ * 255, new Byte4(Vector4.UnitZ * 255).ToVector4()); - Assert.Equal(Vector4.UnitW * 255, new Byte4(Vector4.UnitW * 255).ToVector4()); - } - - [Fact] - public void Byte4_ToScaledVector4() - { - // arrange - var byte4 = new Byte4(Vector4.One * 255); - - // act - Vector4 actual = byte4.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Byte4_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4(); - var pixel = default(Byte4); - uint expected = 0xFFFFFFFF; - - // act - pixel.PackFromScaledVector4(scaled); - uint actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_Clamping() - { - Assert.True(Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4())); - } - - [Fact] - public void Byte4_ToRgb24() - { - // arrange - var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(128, 0, 0); - - // act - byte4.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_Rgba32() - { - // arrange - var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(128, 0, 0, 0); - - // act - byte4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_ToBgr24() - { - // arrange - var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(128, 0, 0); - - // act - byte4.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_Bgra32() - { - // arrange - var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); - var actual = default(Bgra32); - var expected = new Bgra32(128, 0, 0, 0); - - // act - byte4.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_Argb32() - { - // arrange - var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); - var actual = default(Argb32); - var expected = new Argb32(128, 0, 0, 0); - - // act - byte4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_PackFromRgba32_ToRgba32() - { - // arrange - var byte4 = default(Byte4); - var actual = default(Rgba32); - var expected = new Rgba32(20, 38, 0, 255); - - // act - byte4.PackFromRgba32(expected); - byte4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_PackFromBgra32_ToBgra32() - { - // arrange - var byte4 = default(Byte4); - var actual = default(Bgra32); - var expected = new Bgra32(20, 38, 0, 255); - - // act - byte4.PackFromBgra32(expected); - byte4.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Byte4_PackFromArgb32_ToArgb32() - { - // arrange - var byte4 = default(Byte4); - var actual = default(Argb32); - var expected = new Argb32(20, 38, 0, 255); - - // act - byte4.PackFromArgb32(expected); - byte4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfSingle_PackedValue() - { - Assert.Equal(11878, new HalfSingle(0.1F).PackedValue); - Assert.Equal(46285, new HalfSingle(-0.3F).PackedValue); - - // Test limits - Assert.Equal(15360, new HalfSingle(1F).PackedValue); - Assert.Equal(0, new HalfSingle(0F).PackedValue); - Assert.Equal(48128, new HalfSingle(-1F).PackedValue); - } - - [Fact] - public void HalfSingle_ToVector4() - { - // arrange - var halfSingle = new HalfSingle(0.5f); - var expected = new Vector4(0.5f, 0, 0, 1); - - // act - var actual = halfSingle.ToVector4(); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfSingle_ToScaledVector4() - { - // arrange - var halfSingle = new HalfSingle(-1F); - - // act - Vector4 actual = halfSingle.ToScaledVector4(); - - // assert - Assert.Equal(0, actual.X); - Assert.Equal(0, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void HalfSingle_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new HalfSingle(-1F).ToScaledVector4(); - int expected = 48128; - var halfSingle = default(HalfSingle); - - // act - halfSingle.PackFromScaledVector4(scaled); - ushort actual = halfSingle.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfSingle_ToRgb24() - { - // arrange - var halfVector = new HalfSingle(.5F); - var actual = default(Rgb24); - var expected = new Rgb24(128, 0, 0); - - // act - halfVector.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfSingle_Rgba32() - { - // arrange - var halfVector = new HalfSingle(.5F); - var actual = default(Rgba32); - var expected = new Rgba32(128, 0, 0, 255); - - // act - halfVector.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfSingle_ToBgr24() - { - // arrange - var halfVector = new HalfSingle(.5F); - var actual = default(Bgr24); - var expected = new Bgr24(128, 0, 0); - - // act - halfVector.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfSingle_Bgra32() - { - // arrange - var halfVector = new HalfSingle(.5F); - var actual = default(Bgra32); - var expected = new Bgra32(128, 0, 0, 255); - - // act - halfVector.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfSingle_Argb32() - { - // arrange - var halfVector = new HalfSingle(.5F); - var actual = default(Argb32); - var expected = new Argb32(128, 0, 0, 255); - - // act - halfVector.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector2_PackedValue() - { - Assert.Equal(0u, new HalfVector2(Vector2.Zero).PackedValue); - Assert.Equal(1006648320u, new HalfVector2(Vector2.One).PackedValue); - Assert.Equal(3033345638u, new HalfVector2(0.1f, -0.3f).PackedValue); - } - - [Fact] - public void HalfVector2_ToVector2() - { - Assert.True(Equal(Vector2.Zero, new HalfVector2(Vector2.Zero).ToVector2())); - Assert.True(Equal(Vector2.One, new HalfVector2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.UnitX, new HalfVector2(Vector2.UnitX).ToVector2())); - Assert.True(Equal(Vector2.UnitY, new HalfVector2(Vector2.UnitY).ToVector2())); - } - - [Fact] - public void HalfVector2_ToScaledVector4() - { - // arrange - var halfVector = new HalfVector2(Vector2.One); - - // act - Vector4 actual = halfVector.ToScaledVector4(); - - // assert - Assert.Equal(1F, actual.X); - Assert.Equal(1F, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void HalfVector2_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4(); - uint expected = 1006648320u; - var halfVector = default(HalfVector2); - - // act - halfVector.PackFromScaledVector4(scaled); - uint actual = halfVector.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector2_ToVector4() - { - // arrange - var halfVector = new HalfVector2(.5F, .25F); - var expected = new Vector4(0.5f, .25F, 0, 1); - - // act - var actual = halfVector.ToVector4(); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector2_ToRgb24() - { - // arrange - var halfVector = new HalfVector2(.5F, .25F); - var actual = default(Rgb24); - var expected = new Rgb24(128, 64, 0); - - // act - halfVector.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector2_Rgba32() - { - // arrange - var halfVector = new HalfVector2(.5F, .25F); - var actual = default(Rgba32); - var expected = new Rgba32(128, 64, 0, 255); - - // act - halfVector.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector2_ToBgr24() - { - // arrange - var halfVector = new HalfVector2(.5F, .25F); - var actual = default(Bgr24); - var expected = new Bgr24(128, 64, 0); - - // act - halfVector.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector2_Bgra32() - { - // arrange - var halfVector = new HalfVector2(.5F, .25F); - var actual = default(Bgra32); - var expected = new Bgra32(128, 64, 0, 255); - - // act - halfVector.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector2_Argb32() - { - // arrange - var halfVector = new HalfVector2(.5F, .25F); - var actual = default(Argb32); - var expected = new Argb32(128, 64, 0, 255); - - // act - halfVector.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_PackedValue() - { - Assert.Equal(0uL, new HalfVector4(Vector4.Zero).PackedValue); - Assert.Equal(4323521613979991040uL, new HalfVector4(Vector4.One).PackedValue); - Assert.Equal(13547034390470638592uL, new HalfVector4(-Vector4.One).PackedValue); - Assert.Equal(15360uL, new HalfVector4(Vector4.UnitX).PackedValue); - Assert.Equal(1006632960uL, new HalfVector4(Vector4.UnitY).PackedValue); - Assert.Equal(65970697666560uL, new HalfVector4(Vector4.UnitZ).PackedValue); - Assert.Equal(4323455642275676160uL, new HalfVector4(Vector4.UnitW).PackedValue); - Assert.Equal(4035285078724390502uL, new HalfVector4(0.1f, 0.3f, 0.4f, 0.5f).PackedValue); - } - - [Fact] - public void HalfVector4_ToVector4() - { - Assert.Equal(Vector4.Zero, new HalfVector4(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.One, new HalfVector4(Vector4.One).ToVector4()); - Assert.Equal(-Vector4.One, new HalfVector4(-Vector4.One).ToVector4()); - Assert.Equal(Vector4.UnitX, new HalfVector4(Vector4.UnitX).ToVector4()); - Assert.Equal(Vector4.UnitY, new HalfVector4(Vector4.UnitY).ToVector4()); - Assert.Equal(Vector4.UnitZ, new HalfVector4(Vector4.UnitZ).ToVector4()); - Assert.Equal(Vector4.UnitW, new HalfVector4(Vector4.UnitW).ToVector4()); - } - - [Fact] - public void HalfVector4_ToScaledVector4() - { - // arrange - var halfVector4 = new HalfVector4(-Vector4.One); - - // act - Vector4 actual = halfVector4.ToScaledVector4(); - - // assert - Assert.Equal(0, actual.X); - Assert.Equal(0, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(0, actual.W); - } - - [Fact] - public void HalfVector4_PackFromScaledVector4() - { - // arrange - var halfVector4 = default(HalfVector4); - Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4(); - ulong expected = 13547034390470638592uL; - - // act - halfVector4.PackFromScaledVector4(scaled); - ulong actual = halfVector4.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_ToRgb24() - { - // arrange - var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); - var actual = default(Rgb24); - var expected = new Rgb24(64, 128, 191); - - // act - halfVector.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_Rgba32() - { - // arrange - var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); - var actual = default(Rgba32); - var expected = new Rgba32(64, 128, 191, 255); - - // act - halfVector.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_ToBgr24() - { - // arrange - var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); - var actual = default(Bgr24); - var expected = new Bgr24(64, 128, 191); - - // act - halfVector.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_Bgra32() - { - // arrange - var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); - var actual = default(Bgra32); - var expected = new Bgra32(64, 128, 191, 255); - - // act - halfVector.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_Argb32() - { - // arrange - var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); - var actual = default(Argb32); - var expected = new Argb32(64, 128, 191, 255); - - // act - halfVector.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_PackFromRgba32_ToRgba32() - { - // arrange - var halVector = default(HalfVector4); - var actual = default(Rgba32); - var expected = new Rgba32(64, 128, 191, 255); - - // act - halVector.PackFromRgba32(expected); - halVector.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_PackFromBgra32_ToBgra32() - { - // arrange - var halVector = default(HalfVector4); - var actual = default(Bgra32); - var expected = new Bgra32(64, 128, 191, 255); - - // act - halVector.PackFromBgra32(expected); - halVector.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void HalfVector4_PackFromArgb32_ToArgb32() - { - // arrange - var halVector = default(HalfVector4); - var actual = default(Argb32); - var expected = new Argb32(64, 128, 191, 255); - - // act - halVector.PackFromArgb32(expected); - halVector.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte2_PackedValue() - { - Assert.Equal(0xda0d, new NormalizedByte2(0.1f, -0.3f).PackedValue); - Assert.Equal(0x0, new NormalizedByte2(Vector2.Zero).PackedValue); - Assert.Equal(0x7F7F, new NormalizedByte2(Vector2.One).PackedValue); - Assert.Equal(0x8181, new NormalizedByte2(-Vector2.One).PackedValue); - } - - [Fact] - public void NormalizedByte2_ToVector2() - { - Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One).ToVector2()); - Assert.Equal(Vector2.Zero, new NormalizedByte2(Vector2.Zero).ToVector2()); - Assert.Equal(-Vector2.One, new NormalizedByte2(-Vector2.One).ToVector2()); - Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One * 1234.0f).ToVector2()); - Assert.Equal(-Vector2.One, new NormalizedByte2(Vector2.One * -1234.0f).ToVector2()); - } - - [Fact] - public void NormalizedByte2_ToVector4() - { - Assert.Equal(new Vector4(1, 1, 0, 1), new NormalizedByte2(Vector2.One).ToVector4()); - Assert.Equal(new Vector4(0, 0, 0, 1), new NormalizedByte2(Vector2.Zero).ToVector4()); - } - - [Fact] - public void NormalizedByte2_ToScaledVector4() - { - // arrange - var byte2 = new NormalizedByte2(-Vector2.One); - - // act - Vector4 actual = byte2.ToScaledVector4(); - - // assert - Assert.Equal(0, actual.X); - Assert.Equal(0, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(1F, actual.W); - } - - [Fact] - public void NormalizedByte2_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4(); - var byte2 = default(NormalizedByte2); - uint expected = 0x8181; - - // act - byte2.PackFromScaledVector4(scaled); - uint actual = byte2.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte2_PackFromRgba32() - { - // arrange - var byte2 = new NormalizedByte2(); - var rgba = new Rgba32(141, 90, 0, 0); - int expected = 0xda0d; - - // act - byte2.PackFromRgba32(rgba); - ushort actual = byte2.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte2_ToRgb24() - { - // arrange - var short4 = new NormalizedByte2(0.1f, -0.3f); - var actual = default(Rgb24); - var expected = new Rgb24(141, 90, 0); - - // act - short4.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte2_ToRgba32() - { - // arrange - var short4 = new NormalizedByte2(0.1f, -0.3f); - var actual = default(Rgba32); - var expected = new Rgba32(141, 90, 0, 255); - - // act - short4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte2_ToBgr24() - { - // arrange - var short4 = new NormalizedByte2(0.1f, -0.3f); - var actual = default(Bgr24); - var expected = new Bgr24(141, 90, 0); - - // act - short4.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte2_ToBgra32() - { - // arrange - var short4 = new NormalizedByte2(0.1f, -0.3f); - var actual = default(Bgra32); - var expected = new Bgra32(141, 90, 0, 255); - - // act - short4.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte2_ToArgb32() - { - // arrange - var short4 = new NormalizedByte2(0.1f, -0.3f); - var actual = default(Argb32); - var expected = new Argb32(141, 90, 0, 255); - - // act - short4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_PackedValues() - { - Assert.Equal(0xA740DA0D, new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); - Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); - Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); - Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); - Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); - } - - [Fact] - public void NormalizedByte4_ToVector4() - { - Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4()); - Assert.Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4()); - Assert.Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4()); - Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4()); - Assert.Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4()); - } - - [Fact] - public void NormalizedByte4_ToScaledVector4() - { - // arrange - var short4 = new NormalizedByte4(-Vector4.One); - - // act - Vector4 actual = short4.ToScaledVector4(); - - // assert - Assert.Equal(0, actual.X); - Assert.Equal(0, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(0, actual.W); - } - - [Fact] - public void NormalizedByte4_PackFromScaledVector4() - { - // arrange - var pixel = default(NormalizedByte4); - Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); - uint expected = 0x81818181; - - // act - pixel.PackFromScaledVector4(scaled); - uint actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_ToRgb24() - { - // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(141, 90, 192); - - // act - short4.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_ToRgba32() - { - // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(141, 90, 192, 39); - - // act - short4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_ToBgr24() - { - // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(141, 90, 192); - - // act - short4.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_ToArgb32() - { - // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Argb32); - var expected = new Argb32(141, 90, 192, 39); - - // act - short4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_PackFromRgba32_ToRgba32() - { - // arrange - var short4 = default(NormalizedByte4); - var actual = default(Rgba32); - var expected = new Rgba32(9, 115, 202, 127); - - // act - short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); - short4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_PackFromBgra32_ToRgba32() - { - // arrange - var actual = default(Bgra32); - var short4 = default(NormalizedByte4); - var expected = new Bgra32(9, 115, 202, 127); - - // act - short4.PackFromBgra32(expected); - short4.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedByte4_PackFromArgb32_ToRgba32() - { - // arrange - var short4 = default(NormalizedByte4); - var actual = default(Argb32); - var expected = new Argb32(9, 115, 202, 127); - - // act - short4.PackFromArgb32(expected); - short4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort2_PackedValue() - { - Assert.Equal(0xE6672CCC, new NormalizedShort2(0.35f, -0.2f).PackedValue); - Assert.Equal(3650751693, new NormalizedShort2(0.1f, -0.3f).PackedValue); - Assert.Equal((uint)0x0, new NormalizedShort2(Vector2.Zero).PackedValue); - Assert.Equal((uint)0x7FFF7FFF, new NormalizedShort2(Vector2.One).PackedValue); - Assert.Equal(0x80018001, new NormalizedShort2(-Vector2.One).PackedValue); - // TODO: I don't think this can ever pass since the bytes are already truncated. - // Assert.Equal(3650751693, n.PackedValue); - } - - [Fact] - public void NormalizedShort2_ToVector2() - { - Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.Zero, new NormalizedShort2(Vector2.Zero).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedShort2(-Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One * 1234.0f).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedShort2(Vector2.One * -1234.0f).ToVector2())); - } - - [Fact] - public void NormalizedShort2_ToVector4() - { - Assert.True(Equal(new Vector4(1, 1, 0, 1), (new NormalizedShort2(Vector2.One)).ToVector4())); - Assert.True(Equal(new Vector4(0, 0, 0, 1), (new NormalizedShort2(Vector2.Zero)).ToVector4())); - } - - [Fact] - public void NormalizedShort2_ToScaledVector4() - { - // arrange - var short2 = new NormalizedShort2(-Vector2.One); - - // act - Vector4 actual = short2.ToScaledVector4(); - - // assert - Assert.Equal(0, actual.X); - Assert.Equal(0, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void NormalizedShort2_PackFromScaledVector4() - { - // arrange - Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4(); - var short2 = default(NormalizedShort2); - uint expected = 0x80018001; - - // act - short2.PackFromScaledVector4(scaled); - uint actual = short2.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort2_PackFromRgba32_ToRgb24() - { - // arrange - var actual = default(Rgb24); - var short2 = new NormalizedShort2(); - var rgba = new Rgba32(141, 90, 0, 0); - var expected = new Rgb24(141, 90, 0); - - // act - short2.PackFromRgba32(rgba); - short2.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort2_ToRgb24() - { - // arrange - var short2 = new NormalizedShort2(0.1f, -0.3f); - var actual = default(Rgb24); - var expected = new Rgb24(141, 90, 0); - - // act - short2.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort2_ToRgba32() - { - // arrange - var short2 = new NormalizedShort2(0.1f, -0.3f); - var actual = default(Rgba32); - var expected = new Rgba32(141, 90, 0, 255); - - // act - short2.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort2_ToBgr24() - { - // arrange - var short2 = new NormalizedShort2(0.1f, -0.3f); - var actual = default(Bgr24); - var expected = new Bgr24(141, 90, 0); - - // act - short2.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort2_ToBgra32() - { - // arrange - var short2 = new NormalizedShort2(0.1f, -0.3f); - var actual = default(Bgra32); - var expected = new Bgra32(141, 90, 0, 255); - - // act - short2.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort2_ToArgb32() - { - // arrange - var short2 = new NormalizedShort2(0.1f, -0.3f); - var actual = default(Argb32); - var expected = new Argb32(141, 90, 0, 255); - - // act - short2.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [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 actual = short4.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void NormalizedShort4_PackFromScaledVector4() - { - // arrange - var pixel = default(NormalizedShort4); - Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); - ulong expected = (ulong)0x7FFF7FFF7FFF7FFF; - - // act - pixel.PackFromScaledVector4(scaled); - ulong actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort4_ToRgb24() - { - // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(141, 90, 192); - - // act - short4.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort4_ToRgba32() - { - // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(141, 90, 192, 39); - - // act - short4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort4_ToBgr24() - { - // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(141, 90, 192); - - // act - short4.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort4_ToArgb32() - { - // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Argb32); - var expected = new Argb32(141, 90, 192, 39); - - // act - short4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort4_PackFromRgba32_ToRgba32() - { - // arrange - var short4 = default(NormalizedShort4); - var expected = new Rgba32(9, 115, 202, 127); - var actual = default(Rgba32); - - // act - short4.PackFromRgba32(expected); - short4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort4_PackFromBgra32_ToRgba32() - { - // arrange - var short4 = default(NormalizedShort4); - var actual = default(Bgra32); - var expected = new Bgra32(9, 115, 202, 127); - - // act - short4.PackFromBgra32(expected); - short4.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void NormalizedShort4_PackFromArgb32_ToRgba32() - { - // arrange - var short4 = default(NormalizedShort4); - var actual = default(Argb32); - var expected = new Argb32(9, 115, 202, 127); - - // act - short4.PackFromArgb32(expected); - short4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rg32_PackedValues() - { - float x = 0xb6dc; - float y = 0xA59f; - Assert.Equal(0xa59fb6dc, new Rg32(x / 0xffff, y / 0xffff).PackedValue); - Assert.Equal((uint)6554, new Rg32(0.1f, -0.3f).PackedValue); - - // Test the limits. - Assert.Equal((uint)0x0, new Rg32(Vector2.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rg32(Vector2.One).PackedValue); - } - - [Fact] - public void Rg32_ToVector2() - { - Assert.Equal(Vector2.Zero, new Rg32(Vector2.Zero).ToVector2()); - Assert.Equal(Vector2.One, new Rg32(Vector2.One).ToVector2()); - } - - [Fact] - public void Rg32_ToScaledVector4() - { - // arrange - var rg32 = new Rg32(Vector2.One); - - // act - Vector4 actual = rg32.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Rg32_PackFromScaledVector4() - { - // arrange - var rg32 = new Rg32(Vector2.One); - var pixel = default(Rg32); - uint expected = 0xFFFFFFFF; - - // act - Vector4 scaled = rg32.ToScaledVector4(); - pixel.PackFromScaledVector4(scaled); - uint actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rg32_Clamping() - { - Assert.True(Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2())); - Assert.True(Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2())); - } - - [Fact] - public void Rg32_ToRgb24() - { - // arrange - var rg32 = new Rg32(0.1f, -0.3f); - var actual = default(Rgb24); - var expected = new Rgb24(25, 0, 0); - - // act - rg32.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rg32_ToRgba32() - { - // arrange - var rg32 = new Rg32(0.1f, -0.3f); - var actual = default(Rgba32); - var expected = new Rgba32(25, 0, 0, 255); - - // act - rg32.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rg32_ToBgr24() - { - // arrange - var rg32 = new Rg32(0.1f, -0.3f); - var actual = default(Bgr24); - var expected = new Bgr24(25, 0, 0); - - // act - rg32.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rg32_ToArgb32() - { - // arrange - var rg32 = new Rg32(0.1f, -0.3f); - var actual = default(Argb32); - var expected = new Argb32(25, 0, 0, 255); - - // act - rg32.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba1010102_PackedValue() - { - float x = 0x2db; - float y = 0x36d; - float z = 0x3b7; - float w = 0x1; - Assert.Equal((uint)0x7B7DB6DB, new Rgba1010102(x / 0x3ff, y / 0x3ff, z / 0x3ff, w / 3).PackedValue); - - Assert.Equal((uint)536871014, new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); - - // Test the limits. - Assert.Equal((uint)0x0, new Rgba1010102(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rgba1010102(Vector4.One).PackedValue); - } - - [Fact] - public void Rgba1010102_ToVector4() - { - Assert.Equal(Vector4.Zero, new Rgba1010102(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.One, new Rgba1010102(Vector4.One).ToVector4()); - } - - [Fact] - public void Rgba1010102_ToScaledVector4() - { - // arrange - var rgba = new Rgba1010102(Vector4.One); - - // act - Vector4 actual = rgba.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Rgba1010102_PackFromScaledVector4() - { - // arrange - var rgba = new Rgba1010102(Vector4.One); - var actual = default(Rgba1010102); - uint expected = 0xFFFFFFFF; - - // act - Vector4 scaled = rgba.ToScaledVector4(); - actual.PackFromScaledVector4(scaled); - - // assert - Assert.Equal(expected, actual.PackedValue); - } - - [Fact] - public void Rgba1010102_Clamping() - { - Assert.True(Equal(Vector4.Zero, new Rgba1010102(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4())); - } - - [Fact] - public void Rgba1010102_ToRgb24() - { - // arrange - var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(25, 0, 128); - - // act - rgba.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba1010102_ToRgba32() - { - // arrange - var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(25, 0, 128, 0); - - // act - rgba.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba1010102_ToBgr24() - { - // arrange - var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(25, 0, 128); - - // act - rgba.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba1010102_ToBgra32() - { - // arrange - var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); - var actual = default(Bgra32); - var expected = new Bgra32(25, 0, 128, 0); - - // act - rgba.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba1010102_PackFromRgba32_ToRgba32() - { - // arrange - var rgba = default(Rgba1010102); - var expected = new Rgba32(25, 0, 128, 0); - var actual = default(Rgba32); - - // act - rgba.PackFromRgba32(expected); - rgba.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba1010102_PackFromBgra32_ToBgra32() - { - // arrange - var rgba = default(Rgba1010102); - var expected = new Bgra32(25, 0, 128, 0); - var actual = default(Bgra32); - - // act - rgba.PackFromBgra32(expected); - rgba.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba1010102_PackFromArgb32_ToArgb32() - { - // arrange - var rgba = default(Rgba1010102); - var expected = new Argb32(25, 0, 128, 0); - var actual = default(Argb32); - - // act - rgba.PackFromArgb32(expected); - rgba.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_PackedValues() - { - Assert.Equal(0x80001Au, new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); - // Test the limits. - Assert.Equal((uint)0x0, new Rgba32(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rgba32(Vector4.One).PackedValue); - } - - [Fact] - public void Rgba32_ToVector4() - { - Assert.True(Equal(Vector4.One, new Rgba32(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Rgba32(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new Rgba32(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new Rgba32(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new Rgba32(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new Rgba32(Vector4.UnitW).ToVector4())); - } - - [Fact] - public void Rgba32_ToScaledVector4() - { - // arrange - var rgba = new Rgba32(Vector4.One); - - // act - Vector4 actual = rgba.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Rgba32_PackFromScaledVector4() - { - // arrange - var rgba = new Rgba32(Vector4.One); - var actual = default(Rgba32); - uint expected = 0xFFFFFFFF; - - // act - Vector4 scaled = rgba.ToScaledVector4(); - actual.PackFromScaledVector4(scaled); - - // assert - Assert.Equal(expected, actual.PackedValue); - } - - [Fact] - public void Rgba32_Clamping() - { - Assert.Equal(Vector4.Zero, new Rgba32(Vector4.One * -1234.0f).ToVector4()); - Assert.Equal(Vector4.One, new Rgba32(Vector4.One * +1234.0f).ToVector4()); - } - - [Fact] - public void Rgba32_ToRgb24() - { - // arrange - var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Rgb24); - var expected = new Rgb24(0x1a, 0, 0x80); - - // act - rgba.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_ToRgba32() - { - // arrange - var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Rgba32); - var expected = new Rgba32(0x1a, 0, 0x80, 0); - - // act - rgba.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_ToBgr24() - { - // arrange - var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Bgr24); - var expected = new Bgr24(0x1a, 0, 0x80); - - // act - rgba.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_ToBgra32() - { - // arrange - var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Bgra32); - var expected = new Bgra32(0x1a, 0, 0x80, 0); - - // act - rgba.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_ToArgb32() - { - // arrange - var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); - var actual = default(Argb32); - var expected = new Argb32(0x1a, 0, 0x80, 0); - - // act - rgba.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_PackFromRgba32_ToRgba32() - { - // arrange - var rgba = default(Rgba32); - var actual = default(Rgba32); - var expected = new Rgba32(0x1a, 0, 0x80, 0); - - // act - rgba.PackFromRgba32(expected); - rgba.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_PackFromBgra32_ToRgba32() - { - // arrange - var rgba = default(Rgba32); - var actual = default(Bgra32); - var expected = new Bgra32(0x1a, 0, 0x80, 0); - - // act - rgba.PackFromBgra32(expected); - rgba.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba32_PackFromArgb32_ToArgb32() - { - // arrange - var rgba = default(Rgba32); - var actual = default(Argb32); - var expected = new Argb32(0x1a, 0, 0x80, 0); - - // act - rgba.PackFromArgb32(expected); - rgba.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba64_PackedValues() - { - Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(0.08f, 0.15f, 0.30f, 0.45f).PackedValue); - // Test the limits. - Assert.Equal((ulong)0x0, new Rgba64(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFFFFFFFFFF, new Rgba64(Vector4.One).PackedValue); - // Test data ordering - Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(((float)0x1EB8) / 0xffff, ((float)0x570A) / 0xffff, ((float)0x8F5C) / 0xffff, ((float)0xC7AD) / 0xffff).PackedValue); - Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(0.12f, 0.34f, 0.56f, 0.78f).PackedValue); - } - - [Fact] - public void Rgba64_ToVector4() - { - Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One).ToVector4())); - } - - [Fact] - public void Rgba64_ToScaledVector4() - { - // arrange - var short2 = new Rgba64(Vector4.One); - - // act - Vector4 actual = short2.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Rgba64_PackFromScaledVector4() - { - // arrange - var pixel = default(Rgba64); - var short4 = new Rgba64(Vector4.One); - ulong expected = 0xFFFFFFFFFFFFFFFF; - - // act - Vector4 scaled = short4.ToScaledVector4(); - pixel.PackFromScaledVector4(scaled); - ulong actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba64_Clamping() - { - Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One * 1234.0f).ToVector4())); - } - - [Fact] - public void Rgba64_ToRgb24() - { - // arrange - var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); - var actual = default(Rgb24); - var expected = new Rgb24(20, 38, 76); - - // act - rgba64.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba64_ToRgba32() - { - // arrange - var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); - var actual = default(Rgba32); - var expected = new Rgba32(20, 38, 76, 115); - - // act - rgba64.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba64_ToBgr24() - { - // arrange - var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); - var actual = default(Bgr24); - var expected = new Bgr24(20, 38, 76); - - // act - rgba64.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba64_ToBgra32() - { - // arrange - var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); - var actual = default(Bgra32); - var expected = new Bgra32(20, 38, 76, 115); - - // act - rgba64.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Rgba64_PackFromRgba32_ToRgba32() - { - // arrange - var rgba64 = default(Rgba64); - var actual = default(Rgba32); - var expected = new Rgba32(20, 38, 76, 115); - - // act - rgba64.PackFromRgba32(expected); - rgba64.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short2_PackedValues() - { - // Test ordering - Assert.Equal((uint)0x361d2db1, new Short2(0x2db1, 0x361d).PackedValue); - Assert.Equal(4294639744, new Short2(127.5f, -5.3f).PackedValue); - // Test the limits. - Assert.Equal((uint)0x0, new Short2(Vector2.Zero).PackedValue); - Assert.Equal((uint)0x7FFF7FFF, new Short2(Vector2.One * 0x7FFF).PackedValue); - Assert.Equal(0x80008000, new Short2(Vector2.One * -0x8000).PackedValue); - } - - [Fact] - public void Short2_ToVector2() - { - Assert.True(Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 0x7FFF).ToVector2())); - Assert.True(Equal(Vector2.Zero, new Short2(Vector2.Zero).ToVector2())); - Assert.True(Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -0x8000).ToVector2())); - Assert.True(Equal(Vector2.UnitX * 0x7FFF, new Short2(Vector2.UnitX * 0x7FFF).ToVector2())); - Assert.True(Equal(Vector2.UnitY * 0x7FFF, new Short2(Vector2.UnitY * 0x7FFF).ToVector2())); - } - - [Fact] - public void Short2_ToVector4() - { - Assert.True(Equal(new Vector4(0x7FFF, 0x7FFF, 0, 1), (new Short2(Vector2.One * 0x7FFF)).ToVector4())); - Assert.True(Equal(new Vector4(0, 0, 0, 1), (new Short2(Vector2.Zero)).ToVector4())); - Assert.True(Equal(new Vector4(-0x8000, -0x8000, 0, 1), (new Short2(Vector2.One * -0x8000)).ToVector4())); - } - - [Fact] - public void Short2_Clamping() - { - Assert.True(Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 1234567.0f).ToVector2())); - Assert.True(Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -1234567.0f).ToVector2())); - } - - [Fact] - public void Short2_ToScaledVector4() - { - // arrange - var short2 = new Short2(Vector2.One * 0x7FFF); - - // act - Vector4 actual = short2.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(0, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Short2_PackFromScaledVector4() - { - // arrange - var pixel = default(Short2); - var short2 = new Short2(Vector2.One * 0x7FFF); - ulong expected = 0x7FFF7FFF; - - // act - Vector4 scaled = short2.ToScaledVector4(); - pixel.PackFromScaledVector4(scaled); - uint actual = pixel.PackedValue; - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short2_ToRgb24() - { - // arrange - var short2 = new Short2(127.5f, -5.3f); - var actual = default(Rgb24); - var expected = new Rgb24(128, 127, 0); - - // act - short2.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short2_ToRgba32() - { - // arrange - var short2 = new Short2(127.5f, -5.3f); - var actual = default(Rgba32); - var expected = new Rgba32(128, 127, 0, 255); - - // act - short2.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short2_ToBgr24() - { - // arrange - var short2 = new Short2(127.5f, -5.3f); - var actual = default(Bgr24); - var expected = new Bgr24(128, 127, 0); - - // act - short2.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short2_ToArgb32() - { - // arrange - var short2 = new Short2(127.5f, -5.3f); - var actual = default(Argb32); - var expected = new Argb32(128, 127, 0, 255); - - // act - short2.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short2_ToBgra32() - { - // arrange - var short2 = new Short2(127.5f, -5.3f); - var actual = default(Bgra32); - var expected = new Bgra32(128, 127, 0, 255); - - // act - short2.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short2_PackFromRgba32_ToRgba32() - { - // arrange - var short2 = default(Short2); - var actual = default(Rgba32); - var expected = new Rgba32(20, 38, 0, 255); - - // act - short2.PackFromRgba32(expected); - short2.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_PackedValues() - { - var shortValue1 = new Short4(11547, 12653, 29623, 193); - var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f); - - Assert.Equal((ulong)0x00c173b7316d2d1b, shortValue1.PackedValue); - Assert.Equal(18446462598732840960, shortValue2.PackedValue); - Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); - Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); - Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); - } - - [Fact] - public void Short4_ToVector4() - { - Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4()); - Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4()); - Assert.Equal(Vector4.UnitX * 0x7FFF, new Short4(Vector4.UnitX * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.UnitY * 0x7FFF, new Short4(Vector4.UnitY * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.UnitZ * 0x7FFF, new Short4(Vector4.UnitZ * 0x7FFF).ToVector4()); - Assert.Equal(Vector4.UnitW * 0x7FFF, new Short4(Vector4.UnitW * 0x7FFF).ToVector4()); - } - - [Fact] - public void Short4_ToScaledVector4() - { - // arrange - var short4 = new Short4(Vector4.One * 0x7FFF); - - // act - Vector4 actual = short4.ToScaledVector4(); - - // assert - Assert.Equal(1, actual.X); - Assert.Equal(1, actual.Y); - Assert.Equal(1, actual.Z); - Assert.Equal(1, actual.W); - } - - [Fact] - public void Short4_PackFromScaledVector4() - { - // arrange - var short4 = new Short4(Vector4.One * 0x7FFF); - Vector4 scaled = short4.ToScaledVector4(); - long expected = 0x7FFF7FFF7FFF7FFF; - - // act - var pixel = default(Short4); - pixel.PackFromScaledVector4(scaled); - ulong actual = pixel.PackedValue; - - // assert - Assert.Equal((ulong)expected, pixel.PackedValue); - } - - [Fact] - public void Short4_Clamping() - { - // arrange - var short1 = new Short4(Vector4.One * 1234567.0f); - var short2 = new Short4(Vector4.One * -1234567.0f); - - // act - var vector1 = short1.ToVector4(); - var vector2 = short2.ToVector4(); - - // assert - Assert.Equal(Vector4.One * 0x7FFF, vector1); - Assert.Equal(Vector4.One * -0x8000, vector2); - } - - [Fact] - public void Short4_ToRgb24() - { - // arrange - var shortValue = new Short4(11547, 12653, 29623, 193); - var actual = default(Rgb24); - var expected = new Rgb24(172, 177, 243); - - // act - shortValue.ToRgb24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_ToBgr24() - { - // arrange - var shortValue = new Short4(11547, 12653, 29623, 193); - var actual = default(Bgr24); - var expected = new Bgr24(172, 177, 243); - - // act - shortValue.ToBgr24(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_ToRgba32() - { - // arrange - var shortValue = new Short4(11547, 12653, 29623, 193); - var actual = default(Rgba32); - var expected = new Rgba32(172, 177, 243, 128); - - // act - shortValue.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_ToBgra32() - { - // arrange - var shortValue = new Short4(11547, 12653, 29623, 193); - var actual = default(Bgra32); - var expected = new Bgra32(172, 177, 243, 128); - - // act - shortValue.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_ToArgb32() - { - // arrange - var shortValue = new Short4(11547, 12653, 29623, 193); - var actual = default(Argb32); - var expected = new Argb32(172, 177, 243, 128); - - // act - shortValue.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_PackFromRgba32_ToRgba32() - { - // arrange - var short4 = default(Short4); - var actual = default(Rgba32); - var expected = new Rgba32(20, 38, 0, 255); - - // act - short4.PackFromRgba32(expected); - short4.ToRgba32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_PackFromBgra32_ToRgba32() - { - // arrange - var short4 = default(Short4); - var actual = default(Bgra32); - var expected = new Bgra32(20, 38, 0, 255); - - // act - short4.PackFromBgra32(expected); - short4.ToBgra32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - [Fact] - public void Short4_PackFromArgb32_ToRgba32() - { - // arrange - var short4 = default(Short4); - var actual = default(Argb32); - var expected = new Argb32(20, 38, 0, 255); - - // act - short4.PackFromArgb32(expected); - short4.ToArgb32(ref actual); - - // assert - Assert.Equal(expected, actual); - } - - // Comparison helpers with small tolerance to allow for floating point rounding during computations. - public static bool Equal(float a, float b) - { - return Math.Abs(a - b) < 1e-5; - } - - public static bool Equal(Vector2 a, Vector2 b) - { - return Equal(a.X, b.X) && Equal(a.Y, b.Y); - } - - public static bool Equal(Vector3 a, Vector3 b) - { - return Equal(a.X, b.X) && Equal(a.Y, b.Y) && Equal(a.Z, b.Z); - } - - public static bool Equal(Vector4 a, Vector4 b) - { - return Equal(a.X, b.X) && Equal(a.Y, b.Y) && Equal(a.Z, b.Z) && Equal(a.W, b.W); - } - } -} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs new file mode 100644 index 000000000..418c22cdb --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs @@ -0,0 +1,129 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Rg32Tests + { + [Fact] + public void Rg32_PackedValues() + { + float x = 0xb6dc; + float y = 0xA59f; + Assert.Equal(0xa59fb6dc, new Rg32(x / 0xffff, y / 0xffff).PackedValue); + Assert.Equal((uint)6554, new Rg32(0.1f, -0.3f).PackedValue); + + // Test the limits. + Assert.Equal((uint)0x0, new Rg32(Vector2.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rg32(Vector2.One).PackedValue); + } + + [Fact] + public void Rg32_ToVector2() + { + Assert.Equal(Vector2.Zero, new Rg32(Vector2.Zero).ToVector2()); + Assert.Equal(Vector2.One, new Rg32(Vector2.One).ToVector2()); + } + + [Fact] + public void Rg32_ToScaledVector4() + { + // arrange + var rg32 = new Rg32(Vector2.One); + + // act + Vector4 actual = rg32.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Rg32_PackFromScaledVector4() + { + // arrange + var rg32 = new Rg32(Vector2.One); + var pixel = default(Rg32); + uint expected = 0xFFFFFFFF; + + // act + Vector4 scaled = rg32.ToScaledVector4(); + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rg32_Clamping() + { + Assert.Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2()); + Assert.Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2()); + } + + [Fact] + public void Rg32_ToRgb24() + { + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 0); + + // act + rg32.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rg32_ToRgba32() + { + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 0, 255); + + // act + rg32.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rg32_ToBgr24() + { + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 0); + + // act + rg32.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rg32_ToArgb32() + { + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(25, 0, 0, 255); + + // act + rg32.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs new file mode 100644 index 000000000..e12a2594c --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs @@ -0,0 +1,179 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Rgba1010102Tests + { + [Fact] + public void Rgba1010102_PackedValue() + { + float x = 0x2db; + float y = 0x36d; + float z = 0x3b7; + float w = 0x1; + Assert.Equal((uint)0x7B7DB6DB, new Rgba1010102(x / 0x3ff, y / 0x3ff, z / 0x3ff, w / 3).PackedValue); + + Assert.Equal((uint)536871014, new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + + // Test the limits. + Assert.Equal((uint)0x0, new Rgba1010102(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rgba1010102(Vector4.One).PackedValue); + } + + [Fact] + public void Rgba1010102_ToVector4() + { + Assert.Equal(Vector4.Zero, new Rgba1010102(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new Rgba1010102(Vector4.One).ToVector4()); + } + + [Fact] + public void Rgba1010102_ToScaledVector4() + { + // arrange + var rgba = new Rgba1010102(Vector4.One); + + // act + Vector4 actual = rgba.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Rgba1010102_PackFromScaledVector4() + { + // arrange + var rgba = new Rgba1010102(Vector4.One); + var actual = default(Rgba1010102); + uint expected = 0xFFFFFFFF; + + // act + Vector4 scaled = rgba.ToScaledVector4(); + actual.PackFromScaledVector4(scaled); + + // assert + Assert.Equal(expected, actual.PackedValue); + } + + [Fact] + public void Rgba1010102_Clamping() + { + Assert.Equal(Vector4.Zero, new Rgba1010102(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Rgba1010102_ToRgb24() + { + // arrange + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 128); + + // act + rgba.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_ToRgba32() + { + // arrange + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 128, 0); + + // act + rgba.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_ToBgr24() + { + // arrange + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 128); + + // act + rgba.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_ToBgra32() + { + // arrange + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(25, 0, 128, 0); + + // act + rgba.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_PackFromRgba32_ToRgba32() + { + // arrange + var rgba = default(Rgba1010102); + var expected = new Rgba32(25, 0, 128, 0); + var actual = default(Rgba32); + + // act + rgba.PackFromRgba32(expected); + rgba.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_PackFromBgra32_ToBgra32() + { + // arrange + var rgba = default(Rgba1010102); + var expected = new Bgra32(25, 0, 128, 0); + var actual = default(Bgra32); + + // act + rgba.PackFromBgra32(expected); + rgba.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_PackFromArgb32_ToArgb32() + { + // arrange + var rgba = default(Rgba1010102); + var expected = new Argb32(25, 0, 128, 0); + var actual = default(Argb32); + + // act + rgba.PackFromArgb32(expected); + rgba.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs index da9ae0858..001a386ba 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs @@ -121,5 +121,187 @@ namespace SixLabors.ImageSharp.Tests Assert.Equal(4, sizeof(Rgba32)); } + + [Fact] + public void Rgba32_PackedValues() + { + Assert.Equal(0x80001Au, new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); + // Test the limits. + Assert.Equal((uint)0x0, new Rgba32(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rgba32(Vector4.One).PackedValue); + } + + [Fact] + public void Rgba32_ToVector4() + { + Assert.Equal(Vector4.One, new Rgba32(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new Rgba32(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX, new Rgba32(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new Rgba32(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new Rgba32(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new Rgba32(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void Rgba32_ToScaledVector4() + { + // arrange + var rgba = new Rgba32(Vector4.One); + + // act + Vector4 actual = rgba.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Rgba32_PackFromScaledVector4() + { + // arrange + var rgba = new Rgba32(Vector4.One); + var actual = default(Rgba32); + uint expected = 0xFFFFFFFF; + + // act + Vector4 scaled = rgba.ToScaledVector4(); + actual.PackFromScaledVector4(scaled); + + // assert + Assert.Equal(expected, actual.PackedValue); + } + + [Fact] + public void Rgba32_Clamping() + { + Assert.Equal(Vector4.Zero, new Rgba32(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Rgba32(Vector4.One * +1234.0f).ToVector4()); + } + + [Fact] + public void Rgba32_ToRgb24() + { + // arrange + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(0x1a, 0, 0x80); + + // act + rgba.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba32_ToRgba32() + { + // arrange + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); + + // act + rgba.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba32_ToBgr24() + { + // arrange + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(0x1a, 0, 0x80); + + // act + rgba.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba32_ToBgra32() + { + // arrange + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); + + // act + rgba.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba32_ToArgb32() + { + // arrange + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); + + // act + rgba.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba32_PackFromRgba32_ToRgba32() + { + // arrange + var rgba = default(Rgba32); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); + + // act + rgba.PackFromRgba32(expected); + rgba.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba32_PackFromBgra32_ToRgba32() + { + // arrange + var rgba = default(Rgba32); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); + + // act + rgba.PackFromBgra32(expected); + rgba.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba32_PackFromArgb32_ToArgb32() + { + // arrange + var rgba = default(Rgba32); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); + + // act + rgba.PackFromArgb32(expected); + rgba.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs new file mode 100644 index 000000000..4c2dfa15a --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs @@ -0,0 +1,144 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Rgba64Tests + { + [Fact] + public void Rgba64_PackedValues() + { + Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(0.08f, 0.15f, 0.30f, 0.45f).PackedValue); + // Test the limits. + Assert.Equal((ulong)0x0, new Rgba64(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFFFFFFFFFF, new Rgba64(Vector4.One).PackedValue); + // Test data ordering + Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(((float)0x1EB8) / 0xffff, ((float)0x570A) / 0xffff, ((float)0x8F5C) / 0xffff, ((float)0xC7AD) / 0xffff).PackedValue); + Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(0.12f, 0.34f, 0.56f, 0.78f).PackedValue); + } + + [Fact] + public void Rgba64_ToVector4() + { + Assert.Equal(Vector4.Zero, new Rgba64(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new Rgba64(Vector4.One).ToVector4()); + } + + [Fact] + public void Rgba64_ToScaledVector4() + { + // arrange + var short2 = new Rgba64(Vector4.One); + + // act + Vector4 actual = short2.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Rgba64_PackFromScaledVector4() + { + // arrange + var pixel = default(Rgba64); + var short4 = new Rgba64(Vector4.One); + ulong expected = 0xFFFFFFFFFFFFFFFF; + + // act + Vector4 scaled = short4.ToScaledVector4(); + pixel.PackFromScaledVector4(scaled); + ulong actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba64_Clamping() + { + Assert.Equal(Vector4.Zero, new Rgba64(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Rgba64(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Rgba64_ToRgb24() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Rgb24); + var expected = new Rgb24(20, 38, 76); + + // act + rgba64.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba64_ToRgba32() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 76, 115); + + // act + rgba64.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba64_ToBgr24() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Bgr24); + var expected = new Bgr24(20, 38, 76); + + // act + rgba64.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba64_ToBgra32() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 76, 115); + + // act + rgba64.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba64_PackFromRgba32_ToRgba32() + { + // arrange + var rgba64 = default(Rgba64); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 76, 115); + + // act + rgba64.PackFromRgba32(expected); + rgba64.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs new file mode 100644 index 000000000..f98180883 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs @@ -0,0 +1,170 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Short2Tests + { + [Fact] + public void Short2_PackedValues() + { + // Test ordering + Assert.Equal((uint)0x361d2db1, new Short2(0x2db1, 0x361d).PackedValue); + Assert.Equal(4294639744, new Short2(127.5f, -5.3f).PackedValue); + // Test the limits. + Assert.Equal((uint)0x0, new Short2(Vector2.Zero).PackedValue); + Assert.Equal((uint)0x7FFF7FFF, new Short2(Vector2.One * 0x7FFF).PackedValue); + Assert.Equal(0x80008000, new Short2(Vector2.One * -0x8000).PackedValue); + } + + [Fact] + public void Short2_ToVector2() + { + Assert.Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 0x7FFF).ToVector2()); + Assert.Equal(Vector2.Zero, new Short2(Vector2.Zero).ToVector2()); + Assert.Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -0x8000).ToVector2()); + Assert.Equal(Vector2.UnitX * 0x7FFF, new Short2(Vector2.UnitX * 0x7FFF).ToVector2()); + Assert.Equal(Vector2.UnitY * 0x7FFF, new Short2(Vector2.UnitY * 0x7FFF).ToVector2()); + } + + [Fact] + public void Short2_ToVector4() + { + Assert.Equal(new Vector4(0x7FFF, 0x7FFF, 0, 1), (new Short2(Vector2.One * 0x7FFF)).ToVector4()); + Assert.Equal(new Vector4(0, 0, 0, 1), (new Short2(Vector2.Zero)).ToVector4()); + Assert.Equal(new Vector4(-0x8000, -0x8000, 0, 1), (new Short2(Vector2.One * -0x8000)).ToVector4()); + } + + [Fact] + public void Short2_Clamping() + { + Assert.Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 1234567.0f).ToVector2()); + Assert.Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -1234567.0f).ToVector2()); + } + + [Fact] + public void Short2_ToScaledVector4() + { + // arrange + var short2 = new Short2(Vector2.One * 0x7FFF); + + // act + Vector4 actual = short2.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Short2_PackFromScaledVector4() + { + // arrange + var pixel = default(Short2); + var short2 = new Short2(Vector2.One * 0x7FFF); + ulong expected = 0x7FFF7FFF; + + // act + Vector4 scaled = short2.ToScaledVector4(); + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short2_ToRgb24() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var actual = default(Rgb24); + var expected = new Rgb24(128, 127, 0); + + // act + short2.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short2_ToRgba32() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var actual = default(Rgba32); + var expected = new Rgba32(128, 127, 0, 255); + + // act + short2.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short2_ToBgr24() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var actual = default(Bgr24); + var expected = new Bgr24(128, 127, 0); + + // act + short2.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short2_ToArgb32() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var actual = default(Argb32); + var expected = new Argb32(128, 127, 0, 255); + + // act + short2.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short2_ToBgra32() + { + // arrange + var short2 = new Short2(127.5f, -5.3f); + var actual = default(Bgra32); + var expected = new Bgra32(128, 127, 0, 255); + + // act + short2.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short2_PackFromRgba32_ToRgba32() + { + // arrange + var short2 = default(Short2); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); + + // act + short2.PackFromRgba32(expected); + short2.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs new file mode 100644 index 000000000..5a1a02c2b --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs @@ -0,0 +1,206 @@ +using System.Numerics; +using SixLabors.ImageSharp.PixelFormats; +using Xunit; + +namespace SixLabors.ImageSharp.Tests.PixelFormats +{ + public class Short4Tests + { + [Fact] + public void Short4_PackedValues() + { + var shortValue1 = new Short4(11547, 12653, 29623, 193); + var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f); + + Assert.Equal((ulong)0x00c173b7316d2d1b, shortValue1.PackedValue); + Assert.Equal(18446462598732840960, shortValue2.PackedValue); + Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); + Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); + Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); + } + + [Fact] + public void Short4_ToVector4() + { + Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4()); + Assert.Equal(Vector4.UnitX * 0x7FFF, new Short4(Vector4.UnitX * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitY * 0x7FFF, new Short4(Vector4.UnitY * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitZ * 0x7FFF, new Short4(Vector4.UnitZ * 0x7FFF).ToVector4()); + Assert.Equal(Vector4.UnitW * 0x7FFF, new Short4(Vector4.UnitW * 0x7FFF).ToVector4()); + } + + [Fact] + public void Short4_ToScaledVector4() + { + // arrange + var short4 = new Short4(Vector4.One * 0x7FFF); + + // act + Vector4 actual = short4.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Short4_PackFromScaledVector4() + { + // arrange + var short4 = new Short4(Vector4.One * 0x7FFF); + Vector4 scaled = short4.ToScaledVector4(); + long expected = 0x7FFF7FFF7FFF7FFF; + + // act + var pixel = default(Short4); + pixel.PackFromScaledVector4(scaled); + ulong actual = pixel.PackedValue; + + // assert + Assert.Equal((ulong)expected, pixel.PackedValue); + } + + [Fact] + public void Short4_Clamping() + { + // arrange + var short1 = new Short4(Vector4.One * 1234567.0f); + var short2 = new Short4(Vector4.One * -1234567.0f); + + // act + var vector1 = short1.ToVector4(); + var vector2 = short2.ToVector4(); + + // assert + Assert.Equal(Vector4.One * 0x7FFF, vector1); + Assert.Equal(Vector4.One * -0x8000, vector2); + } + + [Fact] + public void Short4_ToRgb24() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var actual = default(Rgb24); + var expected = new Rgb24(172, 177, 243); + + // act + shortValue.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short4_ToBgr24() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var actual = default(Bgr24); + var expected = new Bgr24(172, 177, 243); + + // act + shortValue.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short4_ToRgba32() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var actual = default(Rgba32); + var expected = new Rgba32(172, 177, 243, 128); + + // act + shortValue.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short4_ToBgra32() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var actual = default(Bgra32); + var expected = new Bgra32(172, 177, 243, 128); + + // act + shortValue.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short4_ToArgb32() + { + // arrange + var shortValue = new Short4(11547, 12653, 29623, 193); + var actual = default(Argb32); + var expected = new Argb32(172, 177, 243, 128); + + // act + shortValue.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short4_PackFromRgba32_ToRgba32() + { + // arrange + var short4 = default(Short4); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); + + // act + short4.PackFromRgba32(expected); + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short4_PackFromBgra32_ToRgba32() + { + // arrange + var short4 = default(Short4); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 0, 255); + + // act + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Short4_PackFromArgb32_ToRgba32() + { + // arrange + var short4 = default(Short4); + var actual = default(Argb32); + var expected = new Argb32(20, 38, 0, 255); + + // act + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + } +} From 14e8d9a69a7ff7dab9733de3751a7309ac935464 Mon Sep 17 00:00:00 2001 From: popow Date: Sat, 2 Jun 2018 20:08:35 +0200 Subject: [PATCH 13/17] changed 2.1.300-rc1-008673 to 2.1.300 --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index deb862197..5a146cea6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,7 +6,7 @@ matrix: - os: linux # Ubuntu 14.04 dist: trusty sudo: required - dotnet: 2.1.300-rc1-008673 + dotnet: 2.1.300 mono: latest # - os: osx # OSX 10.11 # osx_image: xcode7.3.1 From 1b23982601eb771b19f2e9df76e779ad0399241e Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 3 Jun 2018 14:49:00 +0200 Subject: [PATCH 14/17] corrected namespace of some pixel format tests to SixLabors.ImageSharp.Tests.PixelFormats --- tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs | 2 +- tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs | 2 +- tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs | 2 +- tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs index ca59cea72..33cdadb66 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs @@ -5,7 +5,7 @@ using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; -namespace SixLabors.ImageSharp.Tests +namespace SixLabors.ImageSharp.Tests.PixelFormats { public class Bgr24Tests { diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs index e3cf86825..71e04269d 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs @@ -5,7 +5,7 @@ using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; -namespace SixLabors.ImageSharp.Tests +namespace SixLabors.ImageSharp.Tests.PixelFormats { public class Bgra32Tests { diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs index 4e85fe7e3..5ba21096e 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs @@ -6,7 +6,7 @@ using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; -namespace SixLabors.ImageSharp.Tests +namespace SixLabors.ImageSharp.Tests.PixelFormats { public class Rgb24Tests { diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs index 001a386ba..c198070ad 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs @@ -6,7 +6,7 @@ using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; -namespace SixLabors.ImageSharp.Tests +namespace SixLabors.ImageSharp.Tests.PixelFormats { /// /// Tests the struct. From 60fc00e51a7e042e55b40127b0fddcba5b6c4648 Mon Sep 17 00:00:00 2001 From: popow Date: Sun, 3 Jun 2018 14:53:25 +0200 Subject: [PATCH 15/17] added missing licence note for the pixel tests --- tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs | 5 ++++- tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs | 5 ++++- 18 files changed, 72 insertions(+), 18 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs index a0d4647fc..56d6043a6 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs index 3cd7f72fa..f432aca8a 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs index c4636e2ee..b1640c33d 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs index 3e208dc20..07667220f 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs index 2ff9431f2..b44651196 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs index 6c221b0dc..b6c623216 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs index e9705d23f..5507243dd 100644 --- a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs index 7adabc10c..fe806e0c9 100644 --- a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs index a0ddfabdf..5744243a4 100644 --- a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs index b13f3d916..418e89ecc 100644 --- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs index 9b71bb72b..1a31b806b 100644 --- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs index cf40badb4..fc952a55c 100644 --- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs index ee6cabdaf..ead301c56 100644 --- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs index 418c22cdb..cbecda8d5 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs index e12a2594c..361dd67b5 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs index 4c2dfa15a..ffe512855 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs index f98180883..b38c33b2a 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; diff --git a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs index 5a1a02c2b..097a53331 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs @@ -1,4 +1,7 @@ -using System.Numerics; +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +using System.Numerics; using SixLabors.ImageSharp.PixelFormats; using Xunit; From 1028fa5902fd90efd96f7522cc15a621c6e98187 Mon Sep 17 00:00:00 2001 From: popow Date: Tue, 5 Jun 2018 20:37:21 +0200 Subject: [PATCH 16/17] using MathF.Round in Pack --- src/ImageSharp/PixelFormats/Rgba64.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/ImageSharp/PixelFormats/Rgba64.cs b/src/ImageSharp/PixelFormats/Rgba64.cs index 1507a258c..5d1aa0067 100644 --- a/src/ImageSharp/PixelFormats/Rgba64.cs +++ b/src/ImageSharp/PixelFormats/Rgba64.cs @@ -221,10 +221,10 @@ namespace SixLabors.ImageSharp.PixelFormats [MethodImpl(MethodImplOptions.AggressiveInlining)] private static ulong Pack(float x, float y, float z, float w) { - return (ulong)Math.Round(x.Clamp(0, 1) * 65535F) | - ((ulong)Math.Round(y.Clamp(0, 1) * 65535F) << 16) | - ((ulong)Math.Round(z.Clamp(0, 1) * 65535F) << 32) | - ((ulong)Math.Round(w.Clamp(0, 1) * 65535F) << 48); + return (ulong)MathF.Round(x.Clamp(0, 1) * 65535F) | + ((ulong)MathF.Round(y.Clamp(0, 1) * 65535F) << 16) | + ((ulong)MathF.Round(z.Clamp(0, 1) * 65535F) << 32) | + ((ulong)MathF.Round(w.Clamp(0, 1) * 65535F) << 48); } } } From cc9b6632462cbd5d9ba4649c56ad52436d918af3 Mon Sep 17 00:00:00 2001 From: popow Date: Thu, 7 Jun 2018 19:13:16 +0200 Subject: [PATCH 17/17] changed assertion in Rgba32_ToRgb24 to check each color channel separately --- tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs index c198070ad..b8645d83c 100644 --- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs @@ -193,7 +193,9 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats rgba.ToRgb24(ref actual); // assert - Assert.Equal(expected, actual); + Assert.Equal(expected.R, actual.R); + Assert.Equal(expected.G, actual.G); + Assert.Equal(expected.B, actual.B); } [Fact]