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 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); } } } diff --git a/tests/ImageSharp.Tests/Issues/Issue594.cs b/tests/ImageSharp.Tests/Issues/Issue594.cs new file mode 100644 index 000000000..81fd59885 --- /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)); // 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)); + + // 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)); // 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)); + + 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 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)); + + 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); + } + } +} diff --git a/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs new file mode 100644 index 000000000..56d6043a6 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Alpha8Tests.cs @@ -0,0 +1,161 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..f432aca8a --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs @@ -0,0 +1,193 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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/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/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs new file mode 100644 index 000000000..b1640c33d --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs @@ -0,0 +1,148 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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/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/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs new file mode 100644 index 000000000..07667220f --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs @@ -0,0 +1,197 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..b44651196 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs @@ -0,0 +1,196 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..b6c623216 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs @@ -0,0 +1,194 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..5507243dd --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs @@ -0,0 +1,145 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..fe806e0c9 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs @@ -0,0 +1,150 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..5744243a4 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs @@ -0,0 +1,192 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..418e89ecc --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs @@ -0,0 +1,161 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..1a31b806b --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs @@ -0,0 +1,172 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..fc952a55c --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs @@ -0,0 +1,165 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..ead301c56 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs @@ -0,0 +1,173 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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 f90b592de..000000000 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ /dev/null @@ -1,1397 +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() - { - // 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); - - // 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); - - // Test ToScaledVector4. - 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. - Alpha8 alpha = default; - alpha.PackFromScaledVector4(scaled); - Assert.Equal(128, alpha.PackedValue); - - // Test Rgb conversion - Rgb24 rgb = default; - Rgba32 rgba = default; - Bgr24 bgr = default; - Bgra32 bgra = default; - Argb32 argb = default; - - alpha.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0, 0, 0)); - - alpha.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0, 0, 0, 128)); - - alpha.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0, 0, 0)); - - alpha.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0, 0, 0, 128)); - - alpha.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0, 0, 0, 128)); - } - - [Fact] - public void Argb32() - { - // Test the limits. - 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())); - - // 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); - - // Test PackFromScaledVector4. - var pixel = default(Argb32); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, 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())); - - 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); - - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb2 = default(Argb32); - - argb.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80)); - - argb.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); - Assert.Equal(rgba, argb.ToRgba32()); - - argb.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80)); - - argb.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - Assert.Equal(bgra, argb.ToBgra32()); - - argb.ToArgb32(ref argb2); - Assert.Equal(argb2, new Argb32(0x1a, 0, 0x80, 0)); - Assert.Equal(argb2, argb.ToArgb32()); - - 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)); - - r = default(Argb32); - r.PackFromBgra32(new Bgra32(0x1a, 0, 0x80, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - - r = default(Argb32); - r.PackFromArgb32(new Argb32(0x1a, 0, 0x80, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); - } - - [Fact] - public void Bgr565() - { - // 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())); - - // 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); - - // Test PackFromScaledVector4. - var pixel = default(Bgr565); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); - - // Test clamping. - Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3())); - Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3())); - - // 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); - - float x = 0.1F; - float y = -0.3F; - float z = 0.5F; - Assert.Equal(6160, new Bgr565(x, y, z).PackedValue); - - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Bgr565(x, y, z).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(25, 0, 132)); - - new Bgr565(x, y, z).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 132, 255)); - - new Bgr565(x, y, z).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(25, 0, 132)); - - new Bgr565(x, y, z).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 132, 255)); - - new Bgr565(x, y, z).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 132, 255)); - } - - [Fact] - public void Bgra4444() - { - // 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); - - // Test PackFromScaledVector4. - var pixel = default(Bgra4444); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); - - // 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())); - - // 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); - - 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); - - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Bgra4444(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(34, 0, 136)); - - new Bgra4444(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(34, 0, 136, 0)); - - new Bgra4444(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(34, 0, 136)); - - new Bgra4444(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(34, 0, 136, 0)); - - new Bgra4444(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(34, 0, 136, 0)); - - 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)); - - r = default(Bgra4444); - r.PackFromBgra32(new Bgra32(34, 0, 136, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(34, 0, 136, 0)); - - r = default(Bgra4444); - r.PackFromArgb32(new Argb32(34, 0, 136, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(34, 0, 136, 0)); - } - - [Fact] - public void Bgra5551() - { - // Test the limits. - Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Bgra5551(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Bgra5551(Vector4.One).ToVector4())); - - // 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); - - // Test PackFromScaledVector4. - var pixel = default(Bgra5551); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); - - // Test clamping. - Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); - Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); - - // 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); - - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Bgra5551(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(24, 0, 131)); - - new Bgra5551(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(24, 0, 131, 0)); - - new Bgra5551(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(24, 0, 131)); - - new Bgra5551(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(24, 0, 131, 0)); - - new Bgra5551(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(24, 0, 131, 0)); - - 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)); - - r = default(Bgra5551); - r.PackFromBgra32(new Bgra32(24, 0, 131, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(24, 0, 131, 0)); - - r = default(Bgra5551); - r.PackFromArgb32(new Argb32(24, 0, 131, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(24, 0, 131, 0)); - } - - [Fact] - public void Byte4() - { - // Test the limits. - Assert.Equal((uint)0x0, new Byte4(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Byte4(Vector4.One * 255).PackedValue); - - // 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())); - - // 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); - - // Test PackFromScaledVector4. - var pixel = default(Byte4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); - - // 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())); - - // 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); - - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Byte4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 0, 0)); - - new Byte4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 0, 0, 0)); - - new Byte4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 0, 0)); - - new Byte4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 0, 0, 0)); - - new Byte4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 0, 0, 0)); - - 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)); - - r = default(Byte4); - r.PackFromBgra32(new Bgra32(20, 38, 0, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 0, 255)); - - r = default(Byte4); - r.PackFromArgb32(new Argb32(20, 38, 0, 255)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(20, 38, 0, 255)); - } - - [Fact] - public void HalfSingle() - { - // Test limits - Assert.Equal(15360, new HalfSingle(1F).PackedValue); - Assert.Equal(0, new HalfSingle(0F).PackedValue); - Assert.Equal(48128, new HalfSingle(-1F).PackedValue); - - // Test values - Assert.Equal(11878, new HalfSingle(0.1F).PackedValue); - Assert.Equal(46285, new HalfSingle(-0.3F).PackedValue); - - // Test ordering - float x = .5F; - Assert.True(Equal(new Vector4(x, 0, 0, 1), new HalfSingle(x).ToVector4())); - - // 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); - - // Test PackFromScaledVector4. - var pixel = default(HalfSingle); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(48128, pixel.PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new HalfSingle(x).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 0, 0)); - - new HalfSingle(x).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 0, 0, 255)); - - new HalfSingle(x).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 0, 0)); - - new HalfSingle(x).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 0, 0, 255)); - - new HalfSingle(x).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 0, 0, 255)); - } - - [Fact] - public void HalfVector2() - { - // 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); - - // Test PackFromScaledVector4. - var pixel = default(HalfVector2); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(1006648320u, pixel.PackedValue); - - // Test ordering - float x = .5F; - float y = .25F; - Assert.True(Equal(new Vector4(x, y, 0, 1), new HalfVector2(x, y).ToVector4())); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new HalfVector2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 64, 0)); - - new HalfVector2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 64, 0, 255)); - - new HalfVector2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 64, 0)); - - new HalfVector2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 64, 0, 255)); - - new HalfVector2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 64, 0, 255)); - } - - [Fact] - public void HalfVector4() - { - // 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); - - // Test PackFromScaledVector4. - var pixel = default(HalfVector4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(13547034390470638592uL, pixel.PackedValue); - - // Test ordering - float x = .25F; - float y = .5F; - float z = .75F; - float w = 1F; - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new HalfVector4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(64, 128, 191)); - - new HalfVector4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(64, 128, 191, 255)); - - new HalfVector4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(64, 128, 191)); - - new HalfVector4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(64, 128, 191, 255)); - - new HalfVector4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(64, 128, 191, 255)); - - 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)); - - r = default(HalfVector4); - r.PackFromBgra32(new Bgra32(64, 128, 191, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(64, 128, 191, 255)); - - 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 NormalizedByte2() - { - // 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); - - // 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())); - - // 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())); - - // 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); - - // Test PackFromScaledVector4. - var pixel = default(NormalizedByte2); - 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); - - new NormalizedByte2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 0)); - - new NormalizedByte2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 0, 255)); - - new NormalizedByte2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(141, 90, 0)); - - new NormalizedByte2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 0, 255)); - - new NormalizedByte2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 0, 255)); - } - - [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() - { - 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)); - - new NormalizedShort2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 0, 255)); - - new NormalizedShort2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 0, 255)); - } - - [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() - { - // 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); - 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)); - - new Rg32(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 0, 255)); - - new Rg32(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 0, 255)); - } - - [Fact] - public void Rgba1010102() - { - // 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)); - - new Rgba1010102(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 128, 0)); - - // 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)); - - r = default(Rgba1010102); - r.PackFromBgra32(new Bgra32(25, 0, 128, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 128, 0)); - - r = default(Rgba1010102); - r.PackFromArgb32(new Argb32(25, 0, 128, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 128, 0)); - } - - [Fact] - public void Rgba32() - { - // 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); - - // Test PackFromScaledVector4. - var pixel = default(Rgba32); - 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)); - - rgba32.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - Assert.Equal(bgra, bgra.ToBgra32()); - - rgba32.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); - Assert.Equal(argb, argb.ToArgb32()); - - 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)); - - r = default(Rgba32); - r.PackFromBgra32(new Bgra32(0x1a, 0, 0x80, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - - r = default(Rgba32); - r.PackFromArgb32(new Argb32(0x1a, 0, 0x80, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); - } - - [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); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One).ToVector4())); - - // 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); - - // Test PackFromScaledVector4. - var pixel = default(Rgba64); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFFFFFFFFFF, pixel.PackedValue); - - // 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())); - - // 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); - - 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); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - - new Rgba64(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(20, 38, 76)); - - new Rgba64(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 76, 115)); - - new Rgba64(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(20, 38, 76)); - - new Rgba64(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 76, 115)); - - 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)); - } - - [Fact] - public void Short2() - { - // 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. - 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. - 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(); - 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(Short2); - 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); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - - new Short2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 127, 0)); - - new Short2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 127, 0, 255)); - - new Short2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 127, 0)); - - new Short2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 127, 0, 255)); - - 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)); - } - - [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)); - - 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(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..cbecda8d5 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs @@ -0,0 +1,132 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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/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/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs new file mode 100644 index 000000000..361dd67b5 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs @@ -0,0 +1,182 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..b8645d83c 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. @@ -121,5 +121,189 @@ 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.R, actual.R); + Assert.Equal(expected.G, actual.G); + Assert.Equal(expected.B, actual.B); + } + + [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..ffe512855 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs @@ -0,0 +1,147 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..b38c33b2a --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs @@ -0,0 +1,173 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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..097a53331 --- /dev/null +++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs @@ -0,0 +1,209 @@ +// Copyright (c) Six Labors and contributors. +// Licensed under the Apache License, Version 2.0. + +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); + } + } +}