Add additional unit tests to improve code coverage. Update licensing

.gitattributes

@@ -85,18 +85,12 @@
 ###############################################################################
 *.basis             binary
 *.dll               binary
-*.eot               binary
 *.exe               binary
-*.otf               binary
 *.pdf               binary
 *.ppt               binary
 *.pptx              binary
 *.pvr               binary
 *.snk               binary
-*.ttc               binary
-*.ttf               binary
-*.woff              binary
-*.woff2             binary
 *.xls               binary
 *.xlsx              binary
 ###############################################################################
@@ -126,6 +120,7 @@
 *.dds               filter=lfs diff=lfs merge=lfs -text
 *.ktx               filter=lfs diff=lfs merge=lfs -text
 *.ktx2              filter=lfs diff=lfs merge=lfs -text
+*.astc              filter=lfs diff=lfs merge=lfs -text
 *.pam               filter=lfs diff=lfs merge=lfs -text
 *.pbm               filter=lfs diff=lfs merge=lfs -text
 *.pgm               filter=lfs diff=lfs merge=lfs -text
@@ -143,3 +138,12 @@
 # Handle ICC files by git lfs
 ###############################################################################
 *.icc               filter=lfs diff=lfs merge=lfs -text
+###############################################################################
+# Handle font files by git lfs
+###############################################################################
+*.eot               filter=lfs diff=lfs merge=lfs -text
+*.otf               filter=lfs diff=lfs merge=lfs -text
+*.ttc               filter=lfs diff=lfs merge=lfs -text
+*.ttf               filter=lfs diff=lfs merge=lfs -text
+*.woff              filter=lfs diff=lfs merge=lfs -text
+*.woff2             filter=lfs diff=lfs merge=lfs -text

ImageSharp.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.0.31903.59
+# Visual Studio Version 18
+VisualStudioVersion = 18.5.11723.231 stable
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_root", "_root", "{C317F1B1-D75E-4C6D-83EB-80367343E0D7}"
 	ProjectSection(SolutionItems) = preProject
@@ -45,6 +45,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ImageSharp", "src\ImageShar
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{56801022-D71A-4FBE-BC5B-CBA08E2284EC}"
 	ProjectSection(SolutionItems) = preProject
+		tests\coverlet.runsettings = tests\coverlet.runsettings
 		tests\Directory.Build.props = tests\Directory.Build.props
 		tests\Directory.Build.targets = tests\Directory.Build.targets
 		tests\ImageSharp.Tests.ruleset = tests\ImageSharp.Tests.ruleset

src/ImageSharp/ColorProfiles/WorkingSpaces/GammaWorkingSpace.cs

@@ -62,6 +62,7 @@ public override bool Equals(object? obj)
 
     /// <inheritdoc/>
     public override int GetHashCode() => HashCode.Combine(
+        typeof(GammaWorkingSpace),
         this.WhitePoint,
         this.ChromaticityCoordinates,
         this.Gamma);

src/ImageSharp/ColorProfiles/WorkingSpaces/RgbWorkingSpace.cs

@@ -70,8 +70,10 @@ public override bool Equals(object? obj)
             return true;
         }
 
-        if (obj is RgbWorkingSpace other)
+        if (obj.GetType() == this.GetType())
         {
+            RgbWorkingSpace other = (RgbWorkingSpace)obj;
+
             return this.WhitePoint.Equals(other.WhitePoint)
                 && this.ChromaticityCoordinates.Equals(other.ChromaticityCoordinates);
         }
@@ -81,5 +83,5 @@ public override bool Equals(object? obj)
 
     /// <inheritdoc/>
     public override int GetHashCode()
-        => HashCode.Combine(this.WhitePoint, this.ChromaticityCoordinates);
+        => HashCode.Combine(this.GetType(), this.WhitePoint, this.ChromaticityCoordinates);
 }

tests/Directory.Build.targets

@@ -19,11 +19,6 @@
   <ItemGroup>
     <!-- Test Dependencies -->
     <PackageReference Update="Colourful" Version="3.2.0" />
-
-    <!--
-    Do not update to 14+ yet. There's differnce in how the BMP decoder handles rounding in 16 bit images.
-    See https://github.com/ImageMagick/ImageMagick/commit/27a0a9c37f18af9c8d823a3ea076f600843b553c
-    -->
     <PackageReference Update="Magick.NET-Q16-AnyCPU" Version="14.11.1" />
     <PackageReference Update="Microsoft.DotNet.RemoteExecutor" Version="10.0.0-beta.25563.105" />
     <PackageReference Update="Microsoft.DotNet.XUnitExtensions" Version="8.0.0-beta.23580.1" />

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs

@@ -7,7 +7,6 @@
 using BenchmarkDotNet.Attributes;
 
 using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.ImageSharp.Tuples;
 
 namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
 
@@ -36,7 +35,7 @@
         }
     }
 
     [Params(64)]
     public int Count { get; set; }
 
     [GlobalSetup]
@@ -225,8 +224,8 @@
     // [Benchmark]
     public void Bitops_Simd()
     {
-        ref Octet<uint> sBase = ref Unsafe.As<Rgba32, Octet<uint>>(ref this.source[0]);
-        ref Octet<uint> dBase = ref Unsafe.As<Bgra32, Octet<uint>>(ref this.dest[0]);
+        ref InlineArray8<uint> sBase = ref Unsafe.As<Rgba32, InlineArray8<uint>>(ref this.source[0]);
+        ref InlineArray8<uint> dBase = ref Unsafe.As<Bgra32, InlineArray8<uint>>(ref this.dest[0]);
 
         for (nuint i = 0; i < (uint)this.Count / 8; i++)
         {
@@ -249,9 +248,9 @@
 #pragma warning restore SA1132 // Do not combine fields
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void BitopsSimdImpl(ref Octet<uint> s, ref Octet<uint> d)
+    private static void BitopsSimdImpl(ref InlineArray8<uint> s, ref InlineArray8<uint> d)
     {
-        Vector<uint> sVec = Unsafe.As<Octet<uint>, Vector<uint>>(ref s);
+        Vector<uint> sVec = Unsafe.As<InlineArray8<uint>, Vector<uint>>(ref s);
         Vector<uint> aMask = new(0xFF00FF00);
         Vector<uint> bMask = new(0x00FF00FF);
 
@@ -274,7 +273,7 @@
         Vector<uint> cc = Unsafe.As<C, Vector<uint>>(ref c);
         Vector<uint> dd = aa + cc;
 
-        d = Unsafe.As<Vector<uint>, Octet<uint>>(ref dd);
+        d = Unsafe.As<Vector<uint>, InlineArray8<uint>>(ref dd);
     }
 
     // [Benchmark]

tests/ImageSharp.Benchmarks/General/Vectorization/WidenBytesToUInt32.cs

@@ -5,8 +5,6 @@
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 
-using SixLabors.ImageSharp.Tuples;
-
 namespace SixLabors.ImageSharp.Benchmarks.General.Vectorization;
 
 [Config(typeof(Config.Short))]
@@ -30,12 +28,22 @@ public void Standard()
     {
         const int N = Count / 8;
 
-        ref Octet<byte> sBase = ref Unsafe.As<byte, Octet<byte>>(ref this.source[0]);
-        ref Octet<uint> dBase = ref Unsafe.As<uint, Octet<uint>>(ref this.dest[0]);
+        ref InlineArray8<byte> sBase = ref Unsafe.As<byte, InlineArray8<byte>>(ref this.source[0]);
+        ref InlineArray8<uint> dBase = ref Unsafe.As<uint, InlineArray8<uint>>(ref this.dest[0]);
 
         for (nuint i = 0; i < N; i++)
         {
-            Unsafe.Add(ref dBase, i).LoadFrom(ref Unsafe.Add(ref sBase, i));
+            ref InlineArray8<byte> source = ref Unsafe.Add(ref sBase, i);
+            ref InlineArray8<uint> destination = ref Unsafe.Add(ref dBase, i);
+
+            destination[0] = source[0];
+            destination[1] = source[1];
+            destination[2] = source[2];
+            destination[3] = source[3];
+            destination[4] = source[4];
+            destination[5] = source[5];
+            destination[6] = source[6];
+            destination[7] = source[7];
         }
     }
 

tests/ImageSharp.Tests/ColorProfiles/RgbWorkingSpaceTests.cs

@@ -0,0 +1,122 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.WorkingSpaces;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles;
+
+/// <summary>
+/// Tests the <see cref="RgbWorkingSpace"/> class.
+/// </summary>
+[Trait("Color", "Conversion")]
+public class RgbWorkingSpaceTests
+{
+    private static readonly ApproximateFloatComparer TolerantComparer = new(1e-5F);
+
+    public static readonly TheoryData<RgbWorkingSpace> WorkingSpaces = new()
+    {
+        KnownRgbWorkingSpaces.SRgb,
+        KnownRgbWorkingSpaces.SRgbSimplified,
+        KnownRgbWorkingSpaces.Rec709,
+        KnownRgbWorkingSpaces.Rec2020,
+        KnownRgbWorkingSpaces.ECIRgbv2,
+        KnownRgbWorkingSpaces.AdobeRgb1998,
+        KnownRgbWorkingSpaces.ApplesRgb,
+        KnownRgbWorkingSpaces.BestRgb,
+        KnownRgbWorkingSpaces.BetaRgb,
+        KnownRgbWorkingSpaces.BruceRgb,
+        KnownRgbWorkingSpaces.CIERgb,
+        KnownRgbWorkingSpaces.ColorMatchRgb,
+        KnownRgbWorkingSpaces.DonRgb4,
+        KnownRgbWorkingSpaces.EktaSpacePS5,
+        KnownRgbWorkingSpaces.NTSCRgb,
+        KnownRgbWorkingSpaces.PALSECAMRgb,
+        KnownRgbWorkingSpaces.ProPhotoRgb,
+        KnownRgbWorkingSpaces.SMPTECRgb,
+        KnownRgbWorkingSpaces.WideGamutRgb
+    };
+
+    [Fact]
+    public void RgbWorkingSpaceEqualityRequiresSameConcreteType()
+    {
+        RgbWorkingSpace sRgb = KnownRgbWorkingSpaces.SRgb;
+        RgbWorkingSpace sRgbSimplified = KnownRgbWorkingSpaces.SRgbSimplified;
+        RgbWorkingSpace rec709 = KnownRgbWorkingSpaces.Rec709;
+
+        Assert.False(sRgb.Equals(sRgbSimplified));
+        Assert.False(sRgbSimplified.Equals(sRgb));
+        Assert.False(sRgb.Equals(rec709));
+        Assert.False(rec709.Equals(sRgb));
+
+        Assert.NotEqual(sRgb.GetHashCode(), sRgbSimplified.GetHashCode());
+        Assert.NotEqual(sRgb.GetHashCode(), rec709.GetHashCode());
+    }
+
+    [Fact]
+    public void RgbWorkingSpaceEqualityMatchesSameConcreteTypeValues()
+    {
+        RgbWorkingSpace x = new SRgbWorkingSpace(
+            KnownRgbWorkingSpaces.SRgb.WhitePoint,
+            KnownRgbWorkingSpaces.SRgb.ChromaticityCoordinates);
+
+        RgbWorkingSpace y = new SRgbWorkingSpace(
+            KnownRgbWorkingSpaces.SRgb.WhitePoint,
+            KnownRgbWorkingSpaces.SRgb.ChromaticityCoordinates);
+
+        Assert.Equal(x, y);
+        Assert.Equal(x.GetHashCode(), y.GetHashCode());
+    }
+
+    [Fact]
+    public void GammaWorkingSpaceEqualityIncludesGamma()
+    {
+        GammaWorkingSpace x = new(
+            2.2F,
+            KnownRgbWorkingSpaces.SRgbSimplified.WhitePoint,
+            KnownRgbWorkingSpaces.SRgbSimplified.ChromaticityCoordinates);
+
+        GammaWorkingSpace y = new(
+            1.8F,
+            KnownRgbWorkingSpaces.SRgbSimplified.WhitePoint,
+            KnownRgbWorkingSpaces.SRgbSimplified.ChromaticityCoordinates);
+
+        Assert.NotEqual(x, y);
+        Assert.NotEqual(x.GetHashCode(), y.GetHashCode());
+    }
+
+    [Theory]
+    [MemberData(nameof(WorkingSpaces))]
+    public void CompressAndExpand_RoundTripsWithTolerance(RgbWorkingSpace workingSpace)
+    {
+        Vector4[] linear =
+        [
+            new(0F, .001F, .18F, 1F), // Endpoint, below the sRGB breakpoint, common middle gray, and opaque alpha.
+            new(.0031308F, .25F, .5F, .75F), // sRGB linear/gamma breakpoint with interior values and partial alpha.
+            new(.75F, .5F, .25F, .5F), // Reversed interior values ensure channel order does not hide errors.
+            new(1F, .8F, .2F, .25F) // Upper endpoint, high/low interior values, and low alpha.
+        ];
+
+        Vector4[] expectedCompressed = new Vector4[linear.Length];
+
+        for (int i = 0; i < linear.Length; i++)
+        {
+            Vector4 compressed = workingSpace.Compress(linear[i]);
+            Vector4 expanded = workingSpace.Expand(compressed);
+
+            expectedCompressed[i] = compressed;
+
+            Assert.Equal(linear[i], expanded, TolerantComparer);
+        }
+
+        Vector4[] actualCompressed = linear.ToArray();
+        workingSpace.Compress(actualCompressed);
+
+        Assert.Equal(expectedCompressed, actualCompressed, TolerantComparer);
+
+        workingSpace.Expand(actualCompressed);
+
+        Assert.Equal(linear, actualCompressed, TolerantComparer);
+    }
+}

tests/ImageSharp.Tests/Common/SimdUtilsTests.Shuffle.cs

@@ -292,7 +292,7 @@ static void RunTest(string serialized)
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
             count,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX | HwIntrinsics.DisableHWIntrinsic);
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX | HwIntrinsics.DisableHWIntrinsic);
     }
 
     [Theory]
@@ -478,7 +478,7 @@ static void RunTest(string serialized)
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
             count,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX | HwIntrinsics.DisableHWIntrinsic);
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX | HwIntrinsics.DisableHWIntrinsic);
     }
 
     private static void TestShuffleFloat4Channel(