Merge branch 'master' into js/quantizer

src/ImageSharp/Configuration.cs

@@ -10,6 +10,7 @@ using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Formats.Tga;
+using SixLabors.ImageSharp.Formats.Tiff;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Processing;
@@ -39,7 +40,7 @@ namespace SixLabors.ImageSharp
         /// <summary>
         /// Initializes a new instance of the <see cref="Configuration" /> class.
         /// </summary>
-        /// <param name="configurationModules">A collection of configuration modules to register</param>
+        /// <param name="configurationModules">A collection of configuration modules to register.</param>
         public Configuration(params IConfigurationModule[] configurationModules)
         {
             if (configurationModules != null)
@@ -77,7 +78,7 @@ namespace SixLabors.ImageSharp
 
         /// <summary>
         /// Gets or sets the size of the buffer to use when working with streams.
-        /// Intitialized with <see cref="DefaultStreamProcessingBufferSize"/> by default.
+        /// Initialized with <see cref="DefaultStreamProcessingBufferSize"/> by default.
         /// </summary>
         public int StreamProcessingBufferSize
         {
@@ -180,6 +181,7 @@ namespace SixLabors.ImageSharp
         /// <see cref="GifConfigurationModule"/>
         /// <see cref="BmpConfigurationModule"/>.
         /// <see cref="TgaConfigurationModule"/>.
+        /// <see cref="TiffConfigurationModule"/>.
         /// </summary>
         /// <returns>The default configuration of <see cref="Configuration"/>.</returns>
         internal static Configuration CreateDefaultInstance()
@@ -189,7 +191,8 @@ namespace SixLabors.ImageSharp
                 new JpegConfigurationModule(),
                 new GifConfigurationModule(),
                 new BmpConfigurationModule(),
-                new TgaConfigurationModule());
+                new TgaConfigurationModule(),
+                new TiffConfigurationModule());
         }
     }
 }

src/ImageSharp/Formats/Tiff/ConfigurationExtensions.cs

@@ -1,23 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-namespace SixLabors.ImageSharp.Formats.Tiff
-{
-    /// <summary>
-    /// Helper methods for the Configuration.
-    /// </summary>
-    public static class ConfigurationExtensions
-    {
-        /// <summary>
-        /// Registers the tiff format detector, encoder and decoder.
-        /// </summary>
-        /// <param name="configuration">The configuration.</param>
-        public static void AddTiff(this Configuration configuration)
-        {
-            configuration.ImageFormatsManager.AddImageFormat(TiffFormat.Instance);
-            configuration.ImageFormatsManager.AddImageFormatDetector(new TiffImageFormatDetector());
-            configuration.ImageFormatsManager.SetDecoder(TiffFormat.Instance, new TiffDecoder());
-            configuration.ImageFormatsManager.SetEncoder(TiffFormat.Instance, new TiffEncoder());
-        }
-    }
-}

src/ImageSharp/Formats/Tiff/Constants/TiffConstants.cs

@@ -96,10 +96,30 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Constants
         public static readonly ushort[] BitsPerSample8Bit = { 8 };
 
         /// <summary>
-        /// The bits per sample for images with 8 bits for each color channel.
+        /// The bits per sample for color images with 2 bits for each color channel.
+        /// </summary>
+        public static readonly ushort[] BitsPerSampleRgb2Bit = { 2, 2, 2 };
+
+        /// <summary>
+        /// The bits per sample for color images with 4 bits for each color channel.
+        /// </summary>
+        public static readonly ushort[] BitsPerSampleRgb4Bit = { 4, 4, 4 };
+
+        /// <summary>
+        /// The bits per sample for color images with 8 bits for each color channel.
         /// </summary>
         public static readonly ushort[] BitsPerSampleRgb8Bit = { 8, 8, 8 };
 
+        /// <summary>
+        /// The bits per sample for color images with 10 bits for each color channel.
+        /// </summary>
+        public static readonly ushort[] BitsPerSampleRgb10Bit = { 10, 10, 10 };
+
+        /// <summary>
+        /// The bits per sample for color images with 14 bits for each color channel.
+        /// </summary>
+        public static readonly ushort[] BitsPerSampleRgb14Bit = { 14, 14, 14 };
+
         /// <summary>
         /// The list of mimetypes that equate to a tiff.
         /// </summary>

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb444TiffColor{TPixel}.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
+{
+    /// <summary>
+    /// Implements the 'RGB' photometric interpretation for 4 bits per color channel images.
+    /// </summary>
+    internal class Rgb444TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        /// <inheritdoc/>
+        public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
+        {
+            var color = default(TPixel);
+
+            int offset = 0;
+
+            var bgra = default(Bgra4444);
+            for (int y = top; y < top + height; y++)
+            {
+                Span<TPixel> pixelRow = pixels.GetRowSpan(y);
+
+                for (int x = left; x < left + width; x += 2)
+                {
+                    byte r = (byte)((data[offset] & 0xF0) >> 4);
+                    byte g = (byte)(data[offset] & 0xF);
+                    offset++;
+                    byte b = (byte)((data[offset] & 0xF0) >> 4);
+
+                    bgra.PackedValue = ToBgraPackedValue(b, g, r);
+                    color.FromScaledVector4(bgra.ToScaledVector4());
+                    pixelRow[x] = color;
+                    if (x + 1 >= pixelRow.Length)
+                    {
+                        offset++;
+                        break;
+                    }
+
+                    r = (byte)(data[offset] & 0xF);
+                    offset++;
+                    g = (byte)((data[offset] & 0xF0) >> 4);
+                    b = (byte)(data[offset] & 0xF);
+                    offset++;
+
+                    bgra.PackedValue = ToBgraPackedValue(b, g, r);
+                    color.FromScaledVector4(bgra.ToScaledVector4());
+                    pixelRow[x + 1] = color;
+                }
+            }
+        }
+
+        private static ushort ToBgraPackedValue(byte b, byte g, byte r) => (ushort)(b | (g << 4) | (r << 8) | (0xF << 12));
+    }
+}

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs

@@ -27,7 +27,6 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
         private readonly ushort bitsPerSampleB;
 
         public RgbPlanarTiffColor(ushort[] bitsPerSample)
-        /* : base(bitsPerSample, null) */
         {
             this.bitsPerSampleR = bitsPerSample[0];
             this.bitsPerSampleG = bitsPerSample[1];

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorDecoderFactory{TPixel}.cs

@@ -57,16 +57,56 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
                     DebugGuard.IsTrue(colorMap == null, "colorMap");
                     return new RgbTiffColor<TPixel>(bitsPerSample);
 
+                case TiffColorType.Rgb222:
+                    DebugGuard.IsTrue(
+                        bitsPerSample.Length == 3
+                        && bitsPerSample[2] == 2
+                        && bitsPerSample[1] == 2
+                        && bitsPerSample[0] == 2,
+                        "bitsPerSample");
+                    DebugGuard.IsTrue(colorMap == null, "colorMap");
+                    return new RgbTiffColor<TPixel>(bitsPerSample);
+
+                case TiffColorType.Rgb444:
+                    DebugGuard.IsTrue(
+                        bitsPerSample.Length == 3
+                        && bitsPerSample[2] == 4
+                        && bitsPerSample[1] == 4
+                        && bitsPerSample[0] == 4,
+                        "bitsPerSample");
+                    DebugGuard.IsTrue(colorMap == null, "colorMap");
+                    return new Rgb444TiffColor<TPixel>();
+
                 case TiffColorType.Rgb888:
                     DebugGuard.IsTrue(
                         bitsPerSample.Length == 3
-                        && bitsPerSample[0] == 8
+                        && bitsPerSample[2] == 8
                         && bitsPerSample[1] == 8
-                        && bitsPerSample[2] == 8,
+                        && bitsPerSample[0] == 8,
                         "bitsPerSample");
                     DebugGuard.IsTrue(colorMap == null, "colorMap");
                     return new Rgb888TiffColor<TPixel>();
 
+                case TiffColorType.Rgb101010:
+                    DebugGuard.IsTrue(
+                        bitsPerSample.Length == 3
+                        && bitsPerSample[2] == 10
+                        && bitsPerSample[1] == 10
+                        && bitsPerSample[0] == 10,
+                        "bitsPerSample");
+                    DebugGuard.IsTrue(colorMap == null, "colorMap");
+                    return new RgbTiffColor<TPixel>(bitsPerSample);
+
+                case TiffColorType.Rgb141414:
+                    DebugGuard.IsTrue(
+                        bitsPerSample.Length == 3
+                        && bitsPerSample[2] == 14
+                        && bitsPerSample[1] == 14
+                        && bitsPerSample[0] == 14,
+                        "bitsPerSample");
+                    DebugGuard.IsTrue(colorMap == null, "colorMap");
+                    return new RgbTiffColor<TPixel>(bitsPerSample);
+
                 case TiffColorType.PaletteColor:
                     DebugGuard.NotNull(bitsPerSample, "bitsPerSample");
                     DebugGuard.NotNull(colorMap, "colorMap");

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorType.cs

@@ -58,11 +58,31 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
         /// </summary>
         Rgb,
 
+        /// <summary>
+        /// RGB color image with 2 bits for each channel.
+        /// </summary>
+        Rgb222,
+
+        /// <summary>
+        /// RGB color image with 4 bits for each channel.
+        /// </summary>
+        Rgb444,
+
         /// <summary>
         /// RGB Full Color. Optimized implementation for 8-bit images.
         /// </summary>
         Rgb888,
 
+        /// <summary>
+        /// RGB color image with 10 bits for each channel.
+        /// </summary>
+        Rgb101010,
+
+        /// <summary>
+        /// RGB color image with 14 bits for each channel.
+        /// </summary>
+        Rgb141414,
+
         /// <summary>
         /// RGB Full Color. Planar configuration of data.
         /// </summary>

src/ImageSharp/Formats/Tiff/TiffBitsPerPixel.cs

@@ -18,14 +18,42 @@ namespace SixLabors.ImageSharp.Formats.Tiff
         /// </summary>
         Bit4 = 4,
 
+        /// <summary>
+        /// 6 bits per pixel. 2 bit for each color channel.
+        ///
+        /// Note: The TiffEncoder does not yet support 2 bits per color channel and will default to 24 bits per pixel instead.
+        /// </summary>
+        Bit6 = 6,
+
         /// <summary>
         /// 8 bits per pixel, grayscale or color palette images.
         /// </summary>
         Bit8 = 8,
 
+        /// <summary>
+        /// 12 bits per pixel. 4 bit for each color channel.
+        ///
+        /// Note: The TiffEncoder does not yet support 4 bits per color channel and will default to 24 bits per pixel instead.
+        /// </summary>
+        Bit12 = 12,
+
         /// <summary>
         /// 24 bits per pixel. One byte for each color channel.
         /// </summary>
         Bit24 = 24,
+
+        /// <summary>
+        /// 30 bits per pixel. 10 bit for each color channel.
+        ///
+        /// Note: The TiffEncoder does not yet support 10 bits per color channel and will default to 24 bits per pixel instead.
+        /// </summary>
+        Bit30 = 30,
+
+        /// <summary>
+        /// 42 bits per pixel. 14 bit for each color channel.
+        ///
+        /// Note: The TiffEncoder does not yet support 14 bits per color channel and will default to 24 bits per pixel instead.
+        /// </summary>
+        Bit42 = 42,
     }
 }

src/ImageSharp/Formats/Tiff/TiffBitsPerSample.cs

@@ -28,9 +28,29 @@ namespace SixLabors.ImageSharp.Formats.Tiff
         /// </summary>
         Bit8 = 8,
 
+        /// <summary>
+        /// Six bits per sample, each channel has 2 bits.
+        /// </summary>
+        Bit6 = 6,
+
+        /// <summary>
+        /// Twelve bits per sample, each channel has 4 bits.
+        /// </summary>
+        Bit12 = 12,
+
         /// <summary>
         /// 24 bits per sample, each color channel has 8 Bits.
         /// </summary>
         Bit24 = 24,
+
+        /// <summary>
+        /// Thirty bits per sample, each channel has 10 bits.
+        /// </summary>
+        Bit30 = 30,
+
+        /// <summary>
+        /// Forty two bits per sample, each channel has 14 bits.
+        /// </summary>
+        Bit42 = 42,
     }
 }

src/ImageSharp/Formats/Tiff/TiffBitsPerSampleExtensions.cs

@@ -21,10 +21,18 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     return TiffConstants.BitsPerSample1Bit;
                 case TiffBitsPerSample.Bit4:
                     return TiffConstants.BitsPerSample4Bit;
+                case TiffBitsPerSample.Bit6:
+                    return TiffConstants.BitsPerSampleRgb2Bit;
                 case TiffBitsPerSample.Bit8:
                     return TiffConstants.BitsPerSample8Bit;
+                case TiffBitsPerSample.Bit12:
+                    return TiffConstants.BitsPerSampleRgb4Bit;
                 case TiffBitsPerSample.Bit24:
                     return TiffConstants.BitsPerSampleRgb8Bit;
+                case TiffBitsPerSample.Bit30:
+                    return TiffConstants.BitsPerSampleRgb10Bit;
+                case TiffBitsPerSample.Bit42:
+                    return TiffConstants.BitsPerSampleRgb14Bit;
 
                 default:
                     return Array.Empty<ushort>();
@@ -41,13 +49,41 @@ namespace SixLabors.ImageSharp.Formats.Tiff
             switch (bitsPerSample.Length)
             {
                 case 3:
-                    if (bitsPerSample[0] == TiffConstants.BitsPerSampleRgb8Bit[0] &&
+                    if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb14Bit[2] &&
+                        bitsPerSample[1] == TiffConstants.BitsPerSampleRgb14Bit[1] &&
+                        bitsPerSample[0] == TiffConstants.BitsPerSampleRgb14Bit[0])
+                    {
+                        return TiffBitsPerSample.Bit42;
+                    }
+
+                    if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb10Bit[2] &&
+                        bitsPerSample[1] == TiffConstants.BitsPerSampleRgb10Bit[1] &&
+                        bitsPerSample[0] == TiffConstants.BitsPerSampleRgb10Bit[0])
+                    {
+                        return TiffBitsPerSample.Bit30;
+                    }
+
+                    if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb8Bit[2] &&
                         bitsPerSample[1] == TiffConstants.BitsPerSampleRgb8Bit[1] &&
-                        bitsPerSample[2] == TiffConstants.BitsPerSampleRgb8Bit[2])
+                        bitsPerSample[0] == TiffConstants.BitsPerSampleRgb8Bit[0])
                     {
                         return TiffBitsPerSample.Bit24;
                     }
 
+                    if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb4Bit[2] &&
+                        bitsPerSample[1] == TiffConstants.BitsPerSampleRgb4Bit[1] &&
+                        bitsPerSample[0] == TiffConstants.BitsPerSampleRgb4Bit[0])
+                    {
+                        return TiffBitsPerSample.Bit12;
+                    }
+
+                    if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb2Bit[2] &&
+                        bitsPerSample[1] == TiffConstants.BitsPerSampleRgb2Bit[1] &&
+                        bitsPerSample[0] == TiffConstants.BitsPerSampleRgb2Bit[0])
+                    {
+                        return TiffBitsPerSample.Bit6;
+                    }
+
                     break;
 
                 case 1:

src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs

@@ -202,7 +202,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff
 
             if (this.PlanarConfiguration == TiffPlanarConfiguration.Chunky)
             {
-                DebugGuard.IsTrue(plane == -1, "Excepted Chunky planar.");
+                DebugGuard.IsTrue(plane == -1, "Expected Chunky planar.");
                 bitsPerPixel = this.BitsPerPixel;
             }
             else
@@ -294,7 +294,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                 int top = rowsPerStrip * stripIndex;
                 if (top + stripHeight > frame.Height)
                 {
-                    // Make sure we ignore any strips that are not needed for the image (if too many are present)
+                    // Make sure we ignore any strips that are not needed for the image (if too many are present).
                     break;
                 }
 

src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Linq;
 using SixLabors.ImageSharp.Formats.Tiff.Compression;
 using SixLabors.ImageSharp.Formats.Tiff.Constants;
@@ -179,7 +180,29 @@ namespace SixLabors.ImageSharp.Formats.Tiff
 
                     if (options.PlanarConfiguration == TiffPlanarConfiguration.Chunky)
                     {
-                        options.ColorType = options.BitsPerSample == TiffBitsPerSample.Bit24 ? TiffColorType.Rgb888 : TiffColorType.Rgb;
+                        switch (options.BitsPerSample)
+                        {
+                            case TiffBitsPerSample.Bit42:
+                                options.ColorType = TiffColorType.Rgb141414;
+                                break;
+
+                            case TiffBitsPerSample.Bit30:
+                                options.ColorType = TiffColorType.Rgb101010;
+                                break;
+
+                            case TiffBitsPerSample.Bit24:
+                                options.ColorType = TiffColorType.Rgb888;
+                                break;
+                            case TiffBitsPerSample.Bit12:
+                                options.ColorType = TiffColorType.Rgb444;
+                                break;
+                            case TiffBitsPerSample.Bit6:
+                                options.ColorType = TiffColorType.Rgb222;
+                                break;
+                            default:
+                                TiffThrowHelper.ThrowNotSupported("Bits per sample is not supported.");
+                                break;
+                        }
                     }
                     else
                     {
@@ -273,9 +296,13 @@ namespace SixLabors.ImageSharp.Formats.Tiff
         {
             TiffBitsPerPixel.Bit1 => TiffBitsPerSample.Bit1,
             TiffBitsPerPixel.Bit4 => TiffBitsPerSample.Bit4,
+            TiffBitsPerPixel.Bit6 => TiffBitsPerSample.Bit6,
             TiffBitsPerPixel.Bit8 => TiffBitsPerSample.Bit8,
+            TiffBitsPerPixel.Bit12 => TiffBitsPerSample.Bit12,
             TiffBitsPerPixel.Bit24 => TiffBitsPerSample.Bit24,
-            _ => TiffBitsPerSample.Bit24,
+            TiffBitsPerPixel.Bit30 => TiffBitsPerSample.Bit30,
+            TiffBitsPerPixel.Bit42 => TiffBitsPerSample.Bit42,
+            _ => throw new NotSupportedException("The bits per pixel are not supported"),
         };
     }
 }

src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs

@@ -306,7 +306,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     case TiffBitsPerPixel.Bit1:
                         if (compression == TiffCompression.Ccitt1D || compression == TiffCompression.CcittGroup3Fax || compression == TiffCompression.CcittGroup4Fax)
                         {
-                            // The “normal” PhotometricInterpretation for bilevel CCITT compressed data is WhiteIsZero.
+                            // The “normal” PhotometricInterpretation for bilevel CCITT compressed data is WhiteIsZero.
                             this.SetEncoderOptions(bitsPerPixel, TiffPhotometricInterpretation.WhiteIsZero, compression, TiffPredictor.None);
                             break;
                         }
@@ -319,6 +319,13 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     case TiffBitsPerPixel.Bit8:
                         this.SetEncoderOptions(bitsPerPixel, photometricInterpretation ?? TiffPhotometricInterpretation.BlackIsZero, compression, predictor);
                         break;
+                    case TiffBitsPerPixel.Bit6:
+                    case TiffBitsPerPixel.Bit12:
+                    case TiffBitsPerPixel.Bit30:
+                    case TiffBitsPerPixel.Bit42:
+                        // Encoding 42, 30, 12 and 6 bits per pixel is not yet supported. Default to 24 bits.
+                        this.SetEncoderOptions(TiffBitsPerPixel.Bit24, TiffPhotometricInterpretation.Rgb, compression, TiffPredictor.None);
+                        break;
                     default:
                         this.SetEncoderOptions(bitsPerPixel, TiffPhotometricInterpretation.Rgb, compression, predictor);
                         break;

src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs

@@ -66,8 +66,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     Value = SoftwareValue
                 };
 
-                this.collector.Add(width);
-                this.collector.Add(height);
+                this.collector.AddOrReplace(width);
+                this.collector.AddOrReplace(height);
 
                 this.ProcessResolution(image.Metadata, rootFrameExifProfile);
                 this.ProcessProfiles(image.Metadata, rootFrameExifProfile, rootFrameXmpBytes);
@@ -227,7 +227,6 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     exifProfile.RemoveValue(ExifTag.IccProfile);
                 }
 
-                TiffMetadata tiffMetadata = imageMetadata.GetTiffMetadata();
                 if (xmpProfile != null)
                 {
                     var xmp = new ExifByteArray(ExifTagValue.XMP, ExifDataType.Byte)
@@ -252,6 +251,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff
 
             public void Process(TiffEncoderCore encoder)
             {
+                var planarConfig = new ExifShort(ExifTagValue.PlanarConfiguration)
+                {
+                    Value = (ushort)TiffPlanarConfiguration.Chunky
+                };
+
                 var samplesPerPixel = new ExifLong(ExifTagValue.SamplesPerPixel)
                 {
                     Value = GetSamplesPerPixel(encoder)
@@ -274,6 +278,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     Value = (ushort)encoder.PhotometricInterpretation
                 };
 
+                this.collector.AddOrReplace(planarConfig);
                 this.collector.AddOrReplace(samplesPerPixel);
                 this.collector.AddOrReplace(bitPerSample);
                 this.collector.AddOrReplace(compression);

src/ImageSharp/Formats/Tiff/Writers/TiffPaletteWriter{TPixel}.cs

@@ -55,23 +55,38 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Writers
         /// <inheritdoc />
         protected override void EncodeStrip(int y, int height, TiffBaseCompressor compressor)
         {
-            Span<byte> pixels = GetStripPixels(((IPixelSource)this.quantizedImage).PixelBuffer, y, height);
+            Span<byte> indexedPixels = GetStripPixels(((IPixelSource)this.quantizedImage).PixelBuffer, y, height);
             if (this.BitsPerPixel == 4)
             {
-                using IMemoryOwner<byte> rows4bitBuffer = this.MemoryAllocator.Allocate<byte>(pixels.Length / 2);
+                int width = this.Image.Width;
+                int halfWidth = width >> 1;
+                int excess = (width & 1) * height; // (width % 2) * height
+                int rows4BitBufferLength = (halfWidth * height) + excess;
+                using IMemoryOwner<byte> rows4bitBuffer = this.MemoryAllocator.Allocate<byte>(rows4BitBufferLength);
                 Span<byte> rows4bit = rows4bitBuffer.GetSpan();
-                int idx = 0;
-                for (int i = 0; i < rows4bit.Length; i++)
+                int idxPixels = 0;
+                int idx4bitRows = 0;
+                for (int row = 0; row < height; row++)
                 {
-                    rows4bit[i] = (byte)((pixels[idx] << 4) | (pixels[idx + 1] & 0xF));
-                    idx += 2;
+                    for (int x = 0; x < halfWidth; x++)
+                    {
+                        rows4bit[idx4bitRows] = (byte)((indexedPixels[idxPixels] << 4) | (indexedPixels[idxPixels + 1] & 0xF));
+                        idxPixels += 2;
+                        idx4bitRows++;
+                    }
+
+                    // Make sure rows are byte-aligned.
+                    if (width % 2 != 0)
+                    {
+                        rows4bit[idx4bitRows++] = (byte)(indexedPixels[idxPixels++] << 4);
+                    }
                 }
 
-                compressor.CompressStrip(rows4bit, height);
+                compressor.CompressStrip(rows4bit.Slice(0, idx4bitRows), height);
             }
             else
             {
-                compressor.CompressStrip(pixels, height);
+                compressor.CompressStrip(indexedPixels, height);
             }
         }
 
@@ -91,7 +106,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Writers
             PixelOperations<TPixel>.Instance.ToRgb48(this.Configuration, quantizedColors, quantizedColorRgb48);
 
             // It can happen that the quantized colors are less than the expected maximum per channel.
-            var diffToMaxColors = this.maxColors - quantizedColors.Length;
+            int diffToMaxColors = this.maxColors - quantizedColors.Length;
 
             // In a TIFF ColorMap, all the Red values come first, followed by the Green values,
             // then the Blue values. Convert the quantized palette to this format.

src/ImageSharp/Image.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
@@ -19,6 +20,8 @@ namespace SixLabors.ImageSharp
     /// </summary>
     public abstract partial class Image : IImage, IConfigurationProvider
     {
+        private bool isDisposed;
+
         private Size size;
         private readonly Configuration configuration;
 
@@ -80,8 +83,15 @@ namespace SixLabors.ImageSharp
         /// <inheritdoc />
         public void Dispose()
         {
+            if (this.isDisposed)
+            {
+                return;
+            }
+
             this.Dispose(true);
             GC.SuppressFinalize(this);
+
+            this.isDisposed = true;
         }
 
         /// <summary>
@@ -89,7 +99,7 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream or encoder is null.</exception>
+        /// <exception cref="ArgumentNullException">Thrown if the stream or encoder is null.</exception>
         public void Save(Stream stream, IImageEncoder encoder)
         {
             Guard.NotNull(stream, nameof(stream));
@@ -148,7 +158,13 @@ namespace SixLabors.ImageSharp
         /// <summary>
         /// Throws <see cref="ObjectDisposedException"/> if the image is disposed.
         /// </summary>
-        internal abstract void EnsureNotDisposed();
+        internal void EnsureNotDisposed()
+        {
+            if (this.isDisposed)
+            {
+                ThrowObjectDisposedException(this.GetType());
+            }
+        }
 
         /// <summary>
         /// Accepts a <see cref="IImageVisitor"/>.
@@ -167,6 +183,9 @@ namespace SixLabors.ImageSharp
         /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         internal abstract Task AcceptAsync(IImageVisitorAsync visitor, CancellationToken cancellationToken);
 
+        [MethodImpl(InliningOptions.ColdPath)]
+        private static void ThrowObjectDisposedException(Type type) => throw new ObjectDisposedException(type.Name);
+
         private class EncodeVisitor : IImageVisitor, IImageVisitorAsync
         {
             private readonly IImageEncoder encoder;

src/ImageSharp/ImageFrameCollection.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 
 namespace SixLabors.ImageSharp
 {
@@ -11,8 +12,10 @@ namespace SixLabors.ImageSharp
     /// Encapsulates a pixel-agnostic collection of <see cref="ImageFrame"/> instances
     /// that make up an <see cref="Image"/>.
     /// </summary>
-    public abstract class ImageFrameCollection : IEnumerable<ImageFrame>
+    public abstract class ImageFrameCollection : IDisposable, IEnumerable<ImageFrame>
     {
+        private bool isDisposed;
+
         /// <summary>
         /// Gets the number of frames.
         /// </summary>
@@ -21,7 +24,15 @@ namespace SixLabors.ImageSharp
         /// <summary>
         /// Gets the root frame.
         /// </summary>
-        public ImageFrame RootFrame => this.NonGenericRootFrame;
+        public ImageFrame RootFrame
+        {
+            get
+            {
+                this.EnsureNotDisposed();
+
+                return this.NonGenericRootFrame;
+            }
+        }
 
         /// <summary>
         /// Gets the root frame. (Implements <see cref="RootFrame"/>.)
@@ -36,7 +47,15 @@ namespace SixLabors.ImageSharp
         /// </value>
         /// <param name="index">The index.</param>
         /// <returns>The <see cref="ImageFrame"/> at the specified index.</returns>
-        public ImageFrame this[int index] => this.NonGenericGetFrame(index);
+        public ImageFrame this[int index]
+        {
+            get
+            {
+                this.EnsureNotDisposed();
+
+                return this.NonGenericGetFrame(index);
+            }
+        }
 
         /// <summary>
         /// Determines the index of a specific <paramref name="frame"/> in the <seealso cref="ImageFrameCollection"/>.
@@ -52,14 +71,24 @@ namespace SixLabors.ImageSharp
         /// <param name="source">The <seealso cref="ImageFrame"/> to clone and insert into the <seealso cref="ImageFrameCollection"/>.</param>
         /// <exception cref="ArgumentException">Frame must have the same dimensions as the image.</exception>
         /// <returns>The cloned <see cref="ImageFrame"/>.</returns>
-        public ImageFrame InsertFrame(int index, ImageFrame source) => this.NonGenericInsertFrame(index, source);
+        public ImageFrame InsertFrame(int index, ImageFrame source)
+        {
+            this.EnsureNotDisposed();
+
+            return this.NonGenericInsertFrame(index, source);
+        }
 
         /// <summary>
         /// Clones the <paramref name="source"/> frame and appends the clone to the end of the collection.
         /// </summary>
         /// <param name="source">The raw pixel data to generate the <seealso cref="ImageFrame{TPixel}"/> from.</param>
         /// <returns>The cloned <see cref="ImageFrame{TPixel}"/>.</returns>
-        public ImageFrame AddFrame(ImageFrame source) => this.NonGenericAddFrame(source);
+        public ImageFrame AddFrame(ImageFrame source)
+        {
+            this.EnsureNotDisposed();
+
+            return this.NonGenericAddFrame(source);
+        }
 
         /// <summary>
         /// Removes the frame at the specified index and frees all freeable resources associated with it.
@@ -91,7 +120,12 @@ namespace SixLabors.ImageSharp
         /// <param name="index">The zero-based index of the frame to export.</param>
         /// <exception cref="InvalidOperationException">Cannot remove last frame.</exception>
         /// <returns>The new <see cref="Image{TPixel}"/> with the specified frame.</returns>
-        public Image ExportFrame(int index) => this.NonGenericExportFrame(index);
+        public Image ExportFrame(int index)
+        {
+            this.EnsureNotDisposed();
+
+            return this.NonGenericExportFrame(index);
+        }
 
         /// <summary>
         /// Creates an <see cref="Image{T}"/> with only the frame at the specified index
@@ -99,7 +133,12 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="index">The zero-based index of the frame to clone.</param>
         /// <returns>The new <see cref="Image{TPixel}"/> with the specified frame.</returns>
-        public Image CloneFrame(int index) => this.NonGenericCloneFrame(index);
+        public Image CloneFrame(int index)
+        {
+            this.EnsureNotDisposed();
+
+            return this.NonGenericCloneFrame(index);
+        }
 
         /// <summary>
         /// Creates a new <seealso cref="ImageFrame{TPixel}" /> and appends it to the end of the collection.
@@ -107,7 +146,12 @@ namespace SixLabors.ImageSharp
         /// <returns>
         /// The new <see cref="ImageFrame{TPixel}" />.
         /// </returns>
-        public ImageFrame CreateFrame() => this.NonGenericCreateFrame();
+        public ImageFrame CreateFrame()
+        {
+            this.EnsureNotDisposed();
+
+            return this.NonGenericCreateFrame();
+        }
 
         /// <summary>
         /// Creates a new <seealso cref="ImageFrame{TPixel}" /> and appends it to the end of the collection.
@@ -116,14 +160,55 @@ namespace SixLabors.ImageSharp
         /// <returns>
         /// The new <see cref="ImageFrame{TPixel}" />.
         /// </returns>
-        public ImageFrame CreateFrame(Color backgroundColor) => this.NonGenericCreateFrame(backgroundColor);
+        public ImageFrame CreateFrame(Color backgroundColor)
+        {
+            this.EnsureNotDisposed();
+
+            return this.NonGenericCreateFrame(backgroundColor);
+        }
 
         /// <inheritdoc />
-        public IEnumerator<ImageFrame> GetEnumerator() => this.NonGenericGetEnumerator();
+        public void Dispose()
+        {
+            if (this.isDisposed)
+            {
+                return;
+            }
+
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+
+            this.isDisposed = true;
+        }
+
+        /// <inheritdoc />
+        public IEnumerator<ImageFrame> GetEnumerator()
+        {
+            this.EnsureNotDisposed();
+
+            return this.NonGenericGetEnumerator();
+        }
 
         /// <inheritdoc/>
         IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
 
+        /// <summary>
+        /// Throws <see cref="ObjectDisposedException"/> if the image frame is disposed.
+        /// </summary>
+        protected void EnsureNotDisposed()
+        {
+            if (this.isDisposed)
+            {
+                ThrowObjectDisposedException(this.GetType());
+            }
+        }
+
+        /// <summary>
+        /// Disposes the object and frees resources for the Garbage Collector.
+        /// </summary>
+        /// <param name="disposing">Whether to dispose of managed and unmanaged objects.</param>
+        protected abstract void Dispose(bool disposing);
+
         /// <summary>
         /// Implements <see cref="GetEnumerator"/>.
         /// </summary>
@@ -178,5 +263,8 @@ namespace SixLabors.ImageSharp
         /// <param name="backgroundColor">The background color.</param>
         /// <returns>The new frame.</returns>
         protected abstract ImageFrame NonGenericCreateFrame(Color backgroundColor);
+
+        [MethodImpl(InliningOptions.ColdPath)]
+        private static void ThrowObjectDisposedException(Type type) => throw new ObjectDisposedException(type.Name);
     }
 }

src/ImageSharp/ImageFrameCollection{TPixel}.cs

@@ -67,7 +67,26 @@ namespace SixLabors.ImageSharp
         /// <summary>
         /// Gets the root frame.
         /// </summary>
-        public new ImageFrame<TPixel> RootFrame => this.frames.Count > 0 ? this.frames[0] : null;
+        public new ImageFrame<TPixel> RootFrame
+        {
+            get
+            {
+                this.EnsureNotDisposed();
+
+                // frame collection would always contain at least 1 frame
+                // the only exception is when collection is disposed what is checked via EnsureNotDisposed() call
+                return this.frames[0];
+            }
+        }
+
+        /// <summary>
+        /// Gets root frame accessor in unsafe manner without any checks.
+        /// </summary>
+        /// <remarks>
+        /// This property is most likely to be called from <see cref="Image{TPixel}"/> for indexing pixels.
+        /// <see cref="Image{TPixel}"/> already checks if it was disposed before querying for root frame.
+        /// </remarks>
+        internal ImageFrame<TPixel> RootFrameUnsafe => this.frames[0];
 
         /// <inheritdoc />
         protected override ImageFrame NonGenericRootFrame => this.RootFrame;
@@ -80,12 +99,22 @@ namespace SixLabors.ImageSharp
         /// </value>
         /// <param name="index">The index.</param>
         /// <returns>The <see cref="ImageFrame{TPixel}"/> at the specified index.</returns>
-        public new ImageFrame<TPixel> this[int index] => this.frames[index];
+        public new ImageFrame<TPixel> this[int index]
+        {
+            get
+            {
+                this.EnsureNotDisposed();
+
+                return this.frames[index];
+            }
+        }
 
         /// <inheritdoc />
         public override int IndexOf(ImageFrame frame)
         {
-            return frame is ImageFrame<TPixel> specific ? this.IndexOf(specific) : -1;
+            this.EnsureNotDisposed();
+
+            return frame is ImageFrame<TPixel> specific ? this.frames.IndexOf(specific) : -1;
         }
 
         /// <summary>
@@ -93,7 +122,12 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="frame">The <seealso cref="ImageFrame{TPixel}"/> to locate in the <seealso cref="ImageFrameCollection{TPixel}"/>.</param>
         /// <returns>The index of item if found in the list; otherwise, -1.</returns>
-        public int IndexOf(ImageFrame<TPixel> frame) => this.frames.IndexOf(frame);
+        public int IndexOf(ImageFrame<TPixel> frame)
+        {
+            this.EnsureNotDisposed();
+
+            return this.frames.IndexOf(frame);
+        }
 
         /// <summary>
         /// Clones and inserts the <paramref name="source"/> into the <seealso cref="ImageFrameCollection{TPixel}"/> at the specified <paramref name="index"/>.
@@ -104,6 +138,8 @@ namespace SixLabors.ImageSharp
         /// <returns>The cloned <see cref="ImageFrame{TPixel}"/>.</returns>
         public ImageFrame<TPixel> InsertFrame(int index, ImageFrame<TPixel> source)
         {
+            this.EnsureNotDisposed();
+
             this.ValidateFrame(source);
             ImageFrame<TPixel> clonedFrame = source.Clone(this.parent.GetConfiguration());
             this.frames.Insert(index, clonedFrame);
@@ -117,6 +153,8 @@ namespace SixLabors.ImageSharp
         /// <returns>The cloned <see cref="ImageFrame{TPixel}"/>.</returns>
         public ImageFrame<TPixel> AddFrame(ImageFrame<TPixel> source)
         {
+            this.EnsureNotDisposed();
+
             this.ValidateFrame(source);
             ImageFrame<TPixel> clonedFrame = source.Clone(this.parent.GetConfiguration());
             this.frames.Add(clonedFrame);
@@ -131,6 +169,8 @@ namespace SixLabors.ImageSharp
         /// <returns>The new <see cref="ImageFrame{TPixel}"/>.</returns>
         public ImageFrame<TPixel> AddFrame(ReadOnlySpan<TPixel> source)
         {
+            this.EnsureNotDisposed();
+
             var frame = ImageFrame.LoadPixelData(
                 this.parent.GetConfiguration(),
                 source,
@@ -149,6 +189,7 @@ namespace SixLabors.ImageSharp
         public ImageFrame<TPixel> AddFrame(TPixel[] source)
         {
             Guard.NotNull(source, nameof(source));
+
             return this.AddFrame(source.AsSpan());
         }
 
@@ -159,6 +200,8 @@ namespace SixLabors.ImageSharp
         /// <exception cref="InvalidOperationException">Cannot remove last frame.</exception>
         public override void RemoveFrame(int index)
         {
+            this.EnsureNotDisposed();
+
             if (index == 0 && this.Count == 1)
             {
                 throw new InvalidOperationException("Cannot remove last frame.");
@@ -170,8 +213,12 @@ namespace SixLabors.ImageSharp
         }
 
         /// <inheritdoc />
-        public override bool Contains(ImageFrame frame) =>
-            frame is ImageFrame<TPixel> specific && this.Contains(specific);
+        public override bool Contains(ImageFrame frame)
+        {
+            this.EnsureNotDisposed();
+
+            return frame is ImageFrame<TPixel> specific && this.frames.Contains(specific);
+        }
 
         /// <summary>
         /// Determines whether the <seealso cref="ImageFrameCollection{TPixel}"/> contains the <paramref name="frame"/>.
@@ -180,7 +227,12 @@ namespace SixLabors.ImageSharp
         /// <returns>
         ///   <c>true</c> if the <seealso cref="ImageFrameCollection{TPixel}"/> contains the specified frame; otherwise, <c>false</c>.
         /// </returns>
-        public bool Contains(ImageFrame<TPixel> frame) => this.frames.Contains(frame);
+        public bool Contains(ImageFrame<TPixel> frame)
+        {
+            this.EnsureNotDisposed();
+
+            return this.frames.Contains(frame);
+        }
 
         /// <summary>
         /// Moves an <seealso cref="ImageFrame{TPixel}"/> from <paramref name="sourceIndex"/> to <paramref name="destinationIndex"/>.
@@ -189,6 +241,8 @@ namespace SixLabors.ImageSharp
         /// <param name="destinationIndex">The index to move the frame to.</param>
         public override void MoveFrame(int sourceIndex, int destinationIndex)
         {
+            this.EnsureNotDisposed();
+
             if (sourceIndex == destinationIndex)
             {
                 return;
@@ -208,6 +262,8 @@ namespace SixLabors.ImageSharp
         /// <returns>The new <see cref="Image{TPixel}"/> with the specified frame.</returns>
         public new Image<TPixel> ExportFrame(int index)
         {
+            this.EnsureNotDisposed();
+
             ImageFrame<TPixel> frame = this[index];
 
             if (this.Count == 1 && this.frames.Contains(frame))
@@ -228,6 +284,8 @@ namespace SixLabors.ImageSharp
         /// <returns>The new <see cref="Image{TPixel}"/> with the specified frame.</returns>
         public new Image<TPixel> CloneFrame(int index)
         {
+            this.EnsureNotDisposed();
+
             ImageFrame<TPixel> frame = this[index];
             ImageFrame<TPixel> clonedFrame = frame.Clone();
             return new Image<TPixel>(this.parent.GetConfiguration(), this.parent.Metadata.DeepClone(), new[] { clonedFrame });
@@ -241,6 +299,8 @@ namespace SixLabors.ImageSharp
         /// </returns>
         public new ImageFrame<TPixel> CreateFrame()
         {
+            this.EnsureNotDisposed();
+
             var frame = new ImageFrame<TPixel>(
                 this.parent.GetConfiguration(),
                 this.RootFrame.Width,
@@ -335,14 +395,18 @@ namespace SixLabors.ImageSharp
             }
         }
 
-        internal void Dispose()
+        /// <inheritdoc/>
+        protected override void Dispose(bool disposing)
         {
-            foreach (ImageFrame<TPixel> f in this.frames)
+            if (disposing)
             {
-                f.Dispose();
-            }
+                foreach (ImageFrame<TPixel> f in this.frames)
+                {
+                    f.Dispose();
+                }
 
-            this.frames.Clear();
+                this.frames.Clear();
+            }
         }
 
         private ImageFrame<TPixel> CopyNonCompatibleFrame(ImageFrame source)

src/ImageSharp/Image{TPixel}.cs

@@ -23,7 +23,7 @@ namespace SixLabors.ImageSharp
     public sealed class Image<TPixel> : Image
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        private bool isDisposed;
+        private readonly ImageFrameCollection<TPixel> frames;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Image{TPixel}"/> class
@@ -84,7 +84,7 @@ namespace SixLabors.ImageSharp
         internal Image(Configuration configuration, int width, int height, ImageMetadata metadata)
             : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, width, height)
         {
-            this.Frames = new ImageFrameCollection<TPixel>(this, width, height, default(TPixel));
+            this.frames = new ImageFrameCollection<TPixel>(this, width, height, default(TPixel));
         }
 
         /// <summary>
@@ -104,7 +104,7 @@ namespace SixLabors.ImageSharp
             ImageMetadata metadata)
             : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, width, height)
         {
-            this.Frames = new ImageFrameCollection<TPixel>(this, width, height, memoryGroup);
+            this.frames = new ImageFrameCollection<TPixel>(this, width, height, memoryGroup);
         }
 
         /// <summary>
@@ -124,7 +124,7 @@ namespace SixLabors.ImageSharp
             ImageMetadata metadata)
             : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, width, height)
         {
-            this.Frames = new ImageFrameCollection<TPixel>(this, width, height, backgroundColor);
+            this.frames = new ImageFrameCollection<TPixel>(this, width, height, backgroundColor);
         }
 
         /// <summary>
@@ -137,7 +137,7 @@ namespace SixLabors.ImageSharp
         internal Image(Configuration configuration, ImageMetadata metadata, IEnumerable<ImageFrame<TPixel>> frames)
             : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, ValidateFramesAndGetSize(frames))
         {
-            this.Frames = new ImageFrameCollection<TPixel>(this, frames);
+            this.frames = new ImageFrameCollection<TPixel>(this, frames);
         }
 
         /// <inheritdoc />
@@ -146,12 +146,19 @@ namespace SixLabors.ImageSharp
         /// <summary>
         /// Gets the collection of image frames.
         /// </summary>
-        public new ImageFrameCollection<TPixel> Frames { get; }
+        public new ImageFrameCollection<TPixel> Frames
+        {
+            get
+            {
+                this.EnsureNotDisposed();
+                return this.frames;
+            }
+        }
 
         /// <summary>
         /// Gets the root frame.
         /// </summary>
-        private IPixelSource<TPixel> PixelSource => this.Frames?.RootFrame ?? throw new ObjectDisposedException(nameof(Image<TPixel>));
+        private IPixelSource<TPixel> PixelSourceUnsafe => this.frames.RootFrameUnsafe;
 
         /// <summary>
         /// Gets or sets the pixel at the specified position.
@@ -165,15 +172,19 @@ namespace SixLabors.ImageSharp
             [MethodImpl(InliningOptions.ShortMethod)]
             get
             {
+                this.EnsureNotDisposed();
+
                 this.VerifyCoords(x, y);
-                return this.PixelSource.PixelBuffer.GetElementUnsafe(x, y);
+                return this.PixelSourceUnsafe.PixelBuffer.GetElementUnsafe(x, y);
             }
 
             [MethodImpl(InliningOptions.ShortMethod)]
             set
             {
+                this.EnsureNotDisposed();
+
                 this.VerifyCoords(x, y);
-                this.PixelSource.PixelBuffer.GetElementUnsafe(x, y) = value;
+                this.PixelSourceUnsafe.PixelBuffer.GetElementUnsafe(x, y) = value;
             }
         }
 
@@ -189,7 +200,9 @@ namespace SixLabors.ImageSharp
             Guard.MustBeGreaterThanOrEqualTo(rowIndex, 0, nameof(rowIndex));
             Guard.MustBeLessThan(rowIndex, this.Height, nameof(rowIndex));
 
-            return this.PixelSource.PixelBuffer.GetRowSpan(rowIndex);
+            this.EnsureNotDisposed();
+
+            return this.PixelSourceUnsafe.PixelBuffer.GetRowSpan(rowIndex);
         }
 
         /// <summary>
@@ -226,10 +239,10 @@ namespace SixLabors.ImageSharp
         {
             this.EnsureNotDisposed();
 
-            var clonedFrames = new ImageFrame<TPixel>[this.Frames.Count];
+            var clonedFrames = new ImageFrame<TPixel>[this.frames.Count];
             for (int i = 0; i < clonedFrames.Length; i++)
             {
-                clonedFrames[i] = this.Frames[i].Clone(configuration);
+                clonedFrames[i] = this.frames[i].Clone(configuration);
             }
 
             return new Image<TPixel>(configuration, this.Metadata.DeepClone(), clonedFrames);
@@ -245,10 +258,10 @@ namespace SixLabors.ImageSharp
         {
             this.EnsureNotDisposed();
 
-            var clonedFrames = new ImageFrame<TPixel2>[this.Frames.Count];
+            var clonedFrames = new ImageFrame<TPixel2>[this.frames.Count];
             for (int i = 0; i < clonedFrames.Length; i++)
             {
-                clonedFrames[i] = this.Frames[i].CloneAs<TPixel2>(configuration);
+                clonedFrames[i] = this.frames[i].CloneAs<TPixel2>(configuration);
             }
 
             return new Image<TPixel2>(configuration, this.Metadata.DeepClone(), clonedFrames);
@@ -257,25 +270,9 @@ namespace SixLabors.ImageSharp
         /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {
-            if (this.isDisposed)
-            {
-                return;
-            }
-
             if (disposing)
             {
-                this.Frames.Dispose();
-            }
-
-            this.isDisposed = true;
-        }
-
-        /// <inheritdoc/>
-        internal override void EnsureNotDisposed()
-        {
-            if (this.isDisposed)
-            {
-                throw new ObjectDisposedException("Trying to execute an operation on a disposed image.");
+                this.frames.Dispose();
             }
         }
 
@@ -306,9 +303,12 @@ namespace SixLabors.ImageSharp
         {
             Guard.NotNull(pixelSource, nameof(pixelSource));
 
-            for (int i = 0; i < this.Frames.Count; i++)
+            this.EnsureNotDisposed();
+
+            ImageFrameCollection<TPixel> sourceFrames = pixelSource.Frames;
+            for (int i = 0; i < this.frames.Count; i++)
             {
-                this.Frames[i].SwapOrCopyPixelsBufferFrom(pixelSource.Frames[i]);
+                this.frames[i].SwapOrCopyPixelsBufferFrom(sourceFrames[i]);
             }
 
             this.UpdateSize(pixelSource.Size());

src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor.cs

@@ -22,10 +22,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
             bool clipHistogram,
             int clipLimit,
             int numberOfTiles)
-            : base(luminanceLevels, clipHistogram, clipLimit)
-        {
-            this.NumberOfTiles = numberOfTiles;
-        }
+            : base(luminanceLevels, clipHistogram, clipLimit) => this.NumberOfTiles = numberOfTiles;
 
         /// <summary>
         /// Gets the number of tiles the image is split into (horizontal and vertically) for the adaptive histogram equalization.
@@ -34,8 +31,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
 
         /// <inheritdoc />
         public override IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>(Configuration configuration, Image<TPixel> source, Rectangle sourceRectangle)
-        {
-            return new AdaptiveHistogramEqualizationProcessor<TPixel>(
+            => new AdaptiveHistogramEqualizationProcessor<TPixel>(
                 configuration,
                 this.LuminanceLevels,
                 this.ClipHistogram,
@@ -43,6 +39,5 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                 this.NumberOfTiles,
                 source,
                 sourceRectangle);
-        }
     }
 }

src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs

@@ -459,10 +459,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
             private readonly Configuration configuration;
             private readonly MemoryAllocator memoryAllocator;
 
-            // Used for storing the minimum value for each CDF entry.
+            /// <summary>
+            /// Used for storing the minimum value for each CDF entry.
+            /// </summary>
             private readonly Buffer2D<int> cdfMinBuffer2D;
 
-            // Used for storing the LUT for each CDF entry.
+            /// <summary>
+            /// Used for storing the LUT for each CDF entry.
+            /// </summary>
             private readonly Buffer2D<int> cdfLutBuffer2D;
             private readonly int pixelsInTile;
             private readonly int sourceWidth;
@@ -596,6 +600,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                         int y = this.tileYStartPositions[index].y;
                         int endY = Math.Min(y + this.tileHeight, this.sourceHeight);
                         Span<int> cdfMinSpan = this.cdfMinBuffer2D.GetRowSpan(cdfY);
+                        cdfMinSpan.Clear();
 
                         using IMemoryOwner<int> histogramBuffer = this.allocator.Allocate<int>(this.luminanceLevels);
                         Span<int> histogram = histogramBuffer.GetSpan();

src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor.cs

@@ -49,44 +49,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         /// </summary>
         /// <param name="options">The <see cref="HistogramEqualizationOptions"/>.</param>
         /// <returns>The <see cref="HistogramEqualizationProcessor"/>.</returns>
-        public static HistogramEqualizationProcessor FromOptions(HistogramEqualizationOptions options)
+        public static HistogramEqualizationProcessor FromOptions(HistogramEqualizationOptions options) => options.Method switch
         {
-            HistogramEqualizationProcessor processor;
+            HistogramEqualizationMethod.Global
+            => new GlobalHistogramEqualizationProcessor(options.LuminanceLevels, options.ClipHistogram, options.ClipLimit),
 
-            switch (options.Method)
-            {
-                case HistogramEqualizationMethod.Global:
-                    processor = new GlobalHistogramEqualizationProcessor(
-                        options.LuminanceLevels,
-                        options.ClipHistogram,
-                        options.ClipLimit);
-                    break;
+            HistogramEqualizationMethod.AdaptiveTileInterpolation
+            => new AdaptiveHistogramEqualizationProcessor(options.LuminanceLevels, options.ClipHistogram, options.ClipLimit, options.NumberOfTiles),
 
-                case HistogramEqualizationMethod.AdaptiveTileInterpolation:
-                    processor = new AdaptiveHistogramEqualizationProcessor(
-                        options.LuminanceLevels,
-                        options.ClipHistogram,
-                        options.ClipLimit,
-                        options.NumberOfTiles);
-                    break;
+            HistogramEqualizationMethod.AdaptiveSlidingWindow
+            => new AdaptiveHistogramEqualizationSlidingWindowProcessor(options.LuminanceLevels, options.ClipHistogram, options.ClipLimit, options.NumberOfTiles),
 
-                case HistogramEqualizationMethod.AdaptiveSlidingWindow:
-                    processor = new AdaptiveHistogramEqualizationSlidingWindowProcessor(
-                        options.LuminanceLevels,
-                        options.ClipHistogram,
-                        options.ClipLimit,
-                        options.NumberOfTiles);
-                    break;
-
-                default:
-                    processor = new GlobalHistogramEqualizationProcessor(
-                        options.LuminanceLevels,
-                        options.ClipHistogram,
-                        options.ClipLimit);
-                    break;
-            }
-
-            return processor;
-        }
+            _ => new GlobalHistogramEqualizationProcessor(options.LuminanceLevels, options.ClipHistogram, options.ClipLimit),
+        };
     }
 }

src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor{TPixel}.cs

@@ -142,6 +142,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         [MethodImpl(InliningOptions.ShortMethod)]
         public static int GetLuminance(TPixel sourcePixel, int luminanceLevels)
         {
+            // TODO: We need a bulk per span equivalent.
             var vector = sourcePixel.ToVector4();
             return ColorNumerics.GetBT709Luminance(ref vector, luminanceLevels);
         }

tests/ImageSharp.Benchmarks/Codecs/DecodeTiff.cs

@@ -9,7 +9,6 @@ using System.IO;
 
 using BenchmarkDotNet.Attributes;
 
-using SixLabors.ImageSharp.Formats.Tiff;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
@@ -23,7 +22,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs
     [Config(typeof(Config.ShortMultiFramework))]
     public class DecodeTiff
     {
-        private string prevImage = null;
+        private string prevImage;
 
         private byte[] data;
 
@@ -68,7 +67,6 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs
             if (this.configuration == null)
             {
                 this.configuration = new Configuration();
-                this.configuration.AddTiff();
                 this.configuration.StreamProcessingBufferSize = BufferSize;
             }
         }

tests/ImageSharp.Benchmarks/Codecs/EncodeTiff.cs

@@ -43,8 +43,6 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs
             if (this.core == null)
             {
                 this.configuration = new Configuration();
-                this.configuration.AddTiff();
-
                 this.core = Image.Load<Rgba32>(this.configuration, this.TestImageFullPath);
                 this.drawing = System.Drawing.Image.FromFile(this.TestImageFullPath);
             }

tests/ImageSharp.Tests.ProfilingSandbox/ImageSharp.Tests.ProfilingSandbox.csproj

@@ -13,6 +13,7 @@
     <IsTestProject>false</IsTestProject>
     <EnsureNETCoreAppRuntime>false</EnsureNETCoreAppRuntime>
     <Configurations>Debug;Release;Release-InnerLoop;Debug-InnerLoop</Configurations>
+    <ValidateExecutableReferencesMatchSelfContained>false</ValidateExecutableReferencesMatchSelfContained>
   </PropertyGroup>
 
   <Choose>

tests/ImageSharp.Tests/ConfigurationTests.cs

@@ -21,11 +21,11 @@ namespace SixLabors.ImageSharp.Tests
 
         public Configuration DefaultConfiguration { get; }
 
-        private readonly int expectedDefaultConfigurationCount = 5;
+        private readonly int expectedDefaultConfigurationCount = 6;
 
         public ConfigurationTests()
         {
-            // the shallow copy of configuration should behave exactly like the default configuration,
+            // The shallow copy of configuration should behave exactly like the default configuration,
             // so by using the copy, we test both the default and the copy.
             this.DefaultConfiguration = Configuration.CreateDefaultInstance().Clone();
             this.ConfigurationEmpty = new Configuration();

tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs

@@ -19,7 +19,7 @@ namespace SixLabors.ImageSharp.Tests.Formats
     public class GeneralFormatTests
     {
         /// <summary>
-        /// A collection made up of one file for each image format
+        /// A collection made up of one file for each image format.
         /// </summary>
         public static readonly IEnumerable<string> DefaultFiles =
             new[]
@@ -149,6 +149,11 @@ namespace SixLabors.ImageSharp.Tests.Formats
                     {
                         image.SaveAsTga(output);
                     }
+
+                    using (FileStream output = File.OpenWrite(Path.Combine(path, $"{file.FileNameWithoutExtension}.tiff")))
+                    {
+                        image.SaveAsTga(output);
+                    }
                 }
             }
         }
@@ -171,7 +176,7 @@ namespace SixLabors.ImageSharp.Tests.Formats
 
                 using (var image2 = Image.Load<Rgba32>(serialized))
                 {
-                    image2.Save($"{path}/{file.FileName}");
+                    image2.Save($"{path}{Path.DirectorySeparatorChar}{file.FileName}");
                 }
             }
         }
@@ -196,6 +201,10 @@ namespace SixLabors.ImageSharp.Tests.Formats
         [InlineData(100, 100, "tga")]
         [InlineData(100, 10, "tga")]
         [InlineData(10, 100, "tga")]
+        [InlineData(100, 100, "tiff")]
+        [InlineData(100, 10, "tiff")]
+        [InlineData(10, 100, "tiff")]
+
         public void CanIdentifyImageLoadedFromBytes(int width, int height, string extension)
         {
             using (var image = Image.LoadPixelData(new Rgba32[width * height], width, height))

tests/ImageSharp.Tests/Formats/Gif/Sections/GifGraphicControlExtensionTests.cs

@@ -1,11 +1,11 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Formats.Gif;
 
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Formats.Gif
+namespace SixLabors.ImageSharp.Tests.Formats.Gif.Sections
 {
     public class GifGraphicControlExtensionTests
     {
@@ -18,4 +18,4 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
             Assert.Equal(14, GifGraphicControlExtension.GetPackedValue(GifDisposalMethod.RestoreToPrevious, true, false));
         }
     }
-}
+}

tests/ImageSharp.Tests/Formats/Gif/Sections/GifImageDescriptorTests.cs

@@ -1,11 +1,11 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Formats.Gif;
 
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Formats.Gif
+namespace SixLabors.ImageSharp.Tests.Formats.Gif.Sections
 {
     public class GifImageDescriptorTests
     {
@@ -21,4 +21,4 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
             Assert.Equal(232, GifImageDescriptor.GetPackedValue(true, true, true, 8));
         }
     }
-}
+}

tests/ImageSharp.Tests/Formats/Gif/Sections/GifLogicalScreenDescriptorTests.cs

@@ -1,11 +1,11 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Formats.Gif;
 
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Formats.Gif
+namespace SixLabors.ImageSharp.Tests.Formats.Gif.Sections
 {
     public class GifLogicalScreenDescriptorTests
     {
@@ -20,4 +20,4 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
             Assert.Equal(55, GifLogicalScreenDescriptor.GetPackedValue(false, 3, false, 7));
         }
     }
-}
+}

tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs

@@ -11,6 +11,7 @@ using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Formats.Tga;
+using SixLabors.ImageSharp.Formats.Tiff;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
 
@@ -36,12 +37,14 @@ namespace SixLabors.ImageSharp.Tests.Formats
             Assert.Equal(1, this.DefaultFormatsManager.ImageEncoders.Select(item => item.Value).OfType<JpegEncoder>().Count());
             Assert.Equal(1, this.DefaultFormatsManager.ImageEncoders.Select(item => item.Value).OfType<GifEncoder>().Count());
             Assert.Equal(1, this.DefaultFormatsManager.ImageEncoders.Select(item => item.Value).OfType<TgaEncoder>().Count());
+            Assert.Equal(1, this.DefaultFormatsManager.ImageEncoders.Select(item => item.Value).OfType<TiffEncoder>().Count());
 
             Assert.Equal(1, this.DefaultFormatsManager.ImageDecoders.Select(item => item.Value).OfType<PngDecoder>().Count());
             Assert.Equal(1, this.DefaultFormatsManager.ImageDecoders.Select(item => item.Value).OfType<BmpDecoder>().Count());
             Assert.Equal(1, this.DefaultFormatsManager.ImageDecoders.Select(item => item.Value).OfType<JpegDecoder>().Count());
             Assert.Equal(1, this.DefaultFormatsManager.ImageDecoders.Select(item => item.Value).OfType<BmpDecoder>().Count());
             Assert.Equal(1, this.DefaultFormatsManager.ImageDecoders.Select(item => item.Value).OfType<TgaDecoder>().Count());
+            Assert.Equal(1, this.DefaultFormatsManager.ImageDecoders.Select(item => item.Value).OfType<TiffDecoder>().Count());
         }
 
         [Fact]

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs

@@ -12,6 +12,7 @@ using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 
 using Xunit;
@@ -117,7 +118,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [Theory]
         [WithFile(TestImages.Jpeg.Baseline.Floorplan, PixelTypes.Rgba32)]
         [WithFile(TestImages.Jpeg.Progressive.Festzug, PixelTypes.Rgba32)]
-        public async Task DecodeAsnc_DegenerateMemoryRequest_ShouldTranslateTo_ImageFormatException<TPixel>(TestImageProvider<TPixel> provider)
+        public async Task DecodeAsync_DegenerateMemoryRequest_ShouldTranslateTo_ImageFormatException<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             provider.LimitAllocatorBufferCapacity().InBytesSqrt(10);
@@ -127,60 +128,53 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         }
 
         [Theory]
-        [InlineData(TestImages.Jpeg.Baseline.Jpeg420Small, 0)]
-        [InlineData(TestImages.Jpeg.Issues.ExifGetString750Transform, 1)]
-        [InlineData(TestImages.Jpeg.Issues.ExifGetString750Transform, 15)]
-        [InlineData(TestImages.Jpeg.Issues.ExifGetString750Transform, 30)]
-        [InlineData(TestImages.Jpeg.Issues.BadRstProgressive518, 1)]
-        [InlineData(TestImages.Jpeg.Issues.BadRstProgressive518, 15)]
-        [InlineData(TestImages.Jpeg.Issues.BadRstProgressive518, 30)]
-        public async Task Decode_IsCancellable(string fileName, int cancellationDelayMs)
+        [InlineData(0)]
+        [InlineData(0.5)]
+        [InlineData(0.9)]
+        public async Task Decode_IsCancellable(int percentageOfStreamReadToCancel)
         {
-            // Decoding these huge files took 300ms on i7-8650U in 2020. 30ms should be safe for cancellation delay.
-            string hugeFile = Path.Combine(
-                TestEnvironment.InputImagesDirectoryFullPath,
-                fileName);
-
-            const int NumberOfRuns = 5;
-
-            for (int i = 0; i < NumberOfRuns; i++)
+            var cts = new CancellationTokenSource();
+            var file = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Jpeg.Baseline.Jpeg420Small);
+            using var pausedStream = new PausedStream(file);
+            pausedStream.OnWaiting(s =>
             {
-                var cts = new CancellationTokenSource();
-                if (cancellationDelayMs == 0)
+                if (s.Position >= s.Length * percentageOfStreamReadToCancel)
                 {
                     cts.Cancel();
+                    pausedStream.Release();
                 }
                 else
                 {
-                    cts.CancelAfter(cancellationDelayMs);
-                }
-
-                try
-                {
-                    using var image = await Image.LoadAsync(hugeFile, cts.Token);
-                }
-                catch (TaskCanceledException)
-                {
-                    // Succesfully observed a cancellation
-                    return;
+                    // allows this/next wait to unblock
+                    pausedStream.Next();
                 }
-            }
+            });
 
-            throw new Exception($"No cancellation happened out of {NumberOfRuns} runs!");
+            var config = Configuration.CreateDefaultInstance();
+            config.FileSystem = new SingleStreamFileSystem(pausedStream);
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                using Image image = await Image.LoadAsync(config, "someFakeFile", cts.Token);
+            });
         }
 
-        [Theory(Skip = "Identify is too fast, doesn't work reliably.")]
-        [InlineData(TestImages.Jpeg.Baseline.Exif)]
-        [InlineData(TestImages.Jpeg.Progressive.Bad.ExifUndefType)]
-        public async Task Identify_IsCancellable(string fileName)
+        [Fact]
+        public async Task Identify_IsCancellable()
         {
-            string file = Path.Combine(
-                TestEnvironment.InputImagesDirectoryFullPath,
-                fileName);
-
             var cts = new CancellationTokenSource();
-            cts.CancelAfter(TimeSpan.FromTicks(1));
-            await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyAsync(file, cts.Token));
+
+            var file = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Jpeg.Baseline.Jpeg420Small);
+            using var pausedStream = new PausedStream(file);
+            pausedStream.OnWaiting(s =>
+            {
+                cts.Cancel();
+                pausedStream.Release();
+            });
+
+            var config = Configuration.CreateDefaultInstance();
+            config.FileSystem = new SingleStreamFileSystem(pausedStream);
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () => await Image.IdentifyAsync(config, "someFakeFile", cts.Token));
         }
 
         // DEBUG ONLY!

tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs

@@ -13,6 +13,7 @@ using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Iptc;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 
 using Xunit;
@@ -310,28 +311,33 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         }
 
         [Theory]
-        [InlineData(JpegSubsample.Ratio420, 0)]
-        [InlineData(JpegSubsample.Ratio420, 3)]
-        [InlineData(JpegSubsample.Ratio420, 10)]
-        [InlineData(JpegSubsample.Ratio444, 0)]
-        [InlineData(JpegSubsample.Ratio444, 3)]
-        [InlineData(JpegSubsample.Ratio444, 10)]
-        public async Task Encode_IsCancellable(JpegSubsample subsample, int cancellationDelayMs)
+        [InlineData(JpegSubsample.Ratio420)]
+        [InlineData(JpegSubsample.Ratio444)]
+        public async Task Encode_IsCancellable(JpegSubsample subsample)
         {
-            using var image = new Image<Rgba32>(5000, 5000);
-            using var stream = new MemoryStream();
             var cts = new CancellationTokenSource();
-            if (cancellationDelayMs == 0)
-            {
-                cts.Cancel();
-            }
-            else
+            using var pausedStream = new PausedStream(new MemoryStream());
+            pausedStream.OnWaiting(s =>
             {
-                cts.CancelAfter(cancellationDelayMs);
-            }
+                // after some writing
+                if (s.Position >= 500)
+                {
+                    cts.Cancel();
+                    pausedStream.Release();
+                }
+                else
+                {
+                    // allows this/next wait to unblock
+                    pausedStream.Next();
+                }
+            });
 
-            var encoder = new JpegEncoder() { Subsample = subsample };
-            await Assert.ThrowsAsync<TaskCanceledException>(() => image.SaveAsync(stream, encoder, cts.Token));
+            using var image = new Image<Rgba32>(5000, 5000);
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var encoder = new JpegEncoder() { Subsample = subsample };
+                await image.SaveAsync(pausedStream, encoder, cts.Token);
+            });
         }
     }
 }

tests/ImageSharp.Tests/Formats/Png/PngFilterTests.cs

@@ -7,7 +7,6 @@ using System;
 
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Formats.Png.Filters;
-using SixLabors.ImageSharp.Tests.Formats.Png.Utils;
 using SixLabors.ImageSharp.Tests.TestUtilities;
 using Xunit;
 using Xunit.Abstractions;
@@ -142,7 +141,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png
                 HwIntrinsics.DisableSIMD);
         }
 
-
         [Fact]
         public void UpAvx2()
         {

tests/ImageSharp.Tests/Formats/Png/PngMetadataTests.cs

@@ -90,12 +90,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png
             using (Image<TPixel> image = provider.GetImage(new PngDecoder()))
             {
                 PngMetadata meta = image.Metadata.GetFormatMetadata(PngFormat.Instance);
-                Assert.DoesNotContain(meta.TextData, m => m.Value.Equals("leading space"));
-                Assert.DoesNotContain(meta.TextData, m => m.Value.Equals("trailing space"));
-                Assert.DoesNotContain(meta.TextData, m => m.Value.Equals("space"));
-                Assert.DoesNotContain(meta.TextData, m => m.Value.Equals("empty"));
-                Assert.DoesNotContain(meta.TextData, m => m.Value.Equals("invalid characters"));
-                Assert.DoesNotContain(meta.TextData, m => m.Value.Equals("too large"));
+                Assert.DoesNotContain(meta.TextData, m => m.Value is "leading space");
+                Assert.DoesNotContain(meta.TextData, m => m.Value is "trailing space");
+                Assert.DoesNotContain(meta.TextData, m => m.Value is "space");
+                Assert.DoesNotContain(meta.TextData, m => m.Value is "empty");
+                Assert.DoesNotContain(meta.TextData, m => m.Value is "invalid characters");
+                Assert.DoesNotContain(meta.TextData, m => m.Value is "too large");
             }
         }
 
@@ -277,20 +277,17 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png
         private static void VerifyTextDataIsPresent(PngMetadata meta)
         {
             Assert.NotNull(meta);
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("Comment") && m.Value.Equals("comment"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("Author") && m.Value.Equals("ImageSharp"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("Copyright") && m.Value.Equals("ImageSharp"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("Title") && m.Value.Equals("unittest"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("Description") && m.Value.Equals("compressed-text"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("International") && m.Value.Equals("'e', mu'tlheghvam, ghaH yu'") &&
-                                                m.LanguageTag.Equals("x-klingon") && m.TranslatedKeyword.Equals("warning"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("International2") && m.Value.Equals("ИМАГЕШАРП") && m.LanguageTag.Equals("rus"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("CompressedInternational") && m.Value.Equals("la plume de la mante") &&
-                                                m.LanguageTag.Equals("fra") && m.TranslatedKeyword.Equals("foobar"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("CompressedInternational2") && m.Value.Equals("這是一個考驗") &&
-                                                m.LanguageTag.Equals("chinese"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("NoLang") && m.Value.Equals("this text chunk is missing a language tag"));
-            Assert.Contains(meta.TextData, m => m.Keyword.Equals("NoTranslatedKeyword") && m.Value.Equals("dieser chunk hat kein übersetztes Schlüßelwort"));
+            Assert.Contains(meta.TextData, m => m.Keyword is "Comment" && m.Value is "comment");
+            Assert.Contains(meta.TextData, m => m.Keyword is "Author" && m.Value is "ImageSharp");
+            Assert.Contains(meta.TextData, m => m.Keyword is "Copyright" && m.Value is "ImageSharp");
+            Assert.Contains(meta.TextData, m => m.Keyword is "Title" && m.Value is "unittest");
+            Assert.Contains(meta.TextData, m => m.Keyword is "Description" && m.Value is "compressed-text");
+            Assert.Contains(meta.TextData, m => m.Keyword is "International" && m.Value is "'e', mu'tlheghvam, ghaH yu'" && m.LanguageTag is "x-klingon" && m.TranslatedKeyword is "warning");
+            Assert.Contains(meta.TextData, m => m.Keyword is "International2" && m.Value is "ИМАГЕШАРП" && m.LanguageTag is "rus");
+            Assert.Contains(meta.TextData, m => m.Keyword is "CompressedInternational" && m.Value is "la plume de la mante" && m.LanguageTag is "fra" && m.TranslatedKeyword is "foobar");
+            Assert.Contains(meta.TextData, m => m.Keyword is "CompressedInternational2" && m.Value is "這是一個考驗" && m.LanguageTag is "chinese");
+            Assert.Contains(meta.TextData, m => m.Keyword is "NoLang" && m.Value is "this text chunk is missing a language tag");
+            Assert.Contains(meta.TextData, m => m.Keyword is "NoTranslatedKeyword" && m.Value is "dieser chunk hat kein übersetztes Schlüßelwort");
         }
     }
 }

tests/ImageSharp.Tests/Formats/Png/ReferenceImplementations.cs

@@ -6,7 +6,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Tests.Formats.Png.Utils
+namespace SixLabors.ImageSharp.Tests.Formats.Png
 {
     /// <summary>
     /// This class contains reference implementations to produce verification data for unit tests

tests/ImageSharp.Tests/Formats/Tiff/ImageExtensionsTest.cs

@@ -13,26 +13,18 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
     [Trait("Format", "Tiff")]
     public class ImageExtensionsTest
     {
-        private readonly Configuration configuration;
-
-        public ImageExtensionsTest()
-        {
-            this.configuration = new Configuration();
-            this.configuration.AddTiff();
-        }
-
         [Fact]
         public void SaveAsTiff_Path()
         {
             string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageExtensionsTest));
             string file = Path.Combine(dir, "SaveAsTiff_Path.tiff");
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 image.SaveAsTiff(file);
             }
 
-            using (Image.Load(this.configuration, file, out IImageFormat mime))
+            using (Image.Load(file, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }
@@ -44,12 +36,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageExtensionsTest));
             string file = Path.Combine(dir, "SaveAsTiffAsync_Path.tiff");
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 await image.SaveAsTiffAsync(file);
             }
 
-            using (Image.Load(this.configuration, file, out IImageFormat mime))
+            using (Image.Load(file, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }
@@ -61,12 +53,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageExtensions));
             string file = Path.Combine(dir, "SaveAsTiff_Path_Encoder.tiff");
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 image.SaveAsTiff(file, new TiffEncoder());
             }
 
-            using (Image.Load(this.configuration, file, out IImageFormat mime))
+            using (Image.Load(file, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }
@@ -78,12 +70,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageExtensions));
             string file = Path.Combine(dir, "SaveAsTiffAsync_Path_Encoder.tiff");
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 await image.SaveAsTiffAsync(file, new TiffEncoder());
             }
 
-            using (Image.Load(this.configuration, file, out IImageFormat mime))
+            using (Image.Load(file, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }
@@ -94,14 +86,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         {
             using var memoryStream = new MemoryStream();
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 image.SaveAsTiff(memoryStream);
             }
 
             memoryStream.Position = 0;
 
-            using (Image.Load(this.configuration, memoryStream, out IImageFormat mime))
+            using (Image.Load(memoryStream, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }
@@ -112,14 +104,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         {
             using var memoryStream = new MemoryStream();
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 await image.SaveAsTiffAsync(memoryStream);
             }
 
             memoryStream.Position = 0;
 
-            using (Image.Load(this.configuration, memoryStream, out IImageFormat mime))
+            using (Image.Load(memoryStream, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }
@@ -130,14 +122,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         {
             using var memoryStream = new MemoryStream();
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 image.SaveAsTiff(memoryStream, new TiffEncoder());
             }
 
             memoryStream.Position = 0;
 
-            using (Image.Load(this.configuration, memoryStream, out IImageFormat mime))
+            using (Image.Load(memoryStream, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }
@@ -148,14 +140,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         {
             using var memoryStream = new MemoryStream();
 
-            using (var image = new Image<Rgba32>(this.configuration, 10, 10))
+            using (var image = new Image<Rgba32>(10, 10))
             {
                 await image.SaveAsTiffAsync(memoryStream, new TiffEncoder());
             }
 
             memoryStream.Position = 0;
 
-            using (Image.Load(this.configuration, memoryStream, out IImageFormat mime))
+            using (Image.Load(memoryStream, out IImageFormat mime))
             {
                 Assert.Equal("image/tiff", mime.DefaultMimeType);
             }

tests/ImageSharp.Tests/Formats/Tiff/TiffDecoderTests.cs

@@ -4,7 +4,7 @@
 // ReSharper disable InconsistentNaming
 using System;
 using System.IO;
-
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Tiff;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
@@ -28,14 +28,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
         private static MagickReferenceDecoder ReferenceDecoder => new MagickReferenceDecoder();
 
-        private readonly Configuration configuration;
-
-        public TiffDecoderTests()
-        {
-            this.configuration = new Configuration();
-            this.configuration.AddTiff();
-        }
-
         [Theory]
         [WithFileCollection(nameof(NotSupportedImages), PixelTypes.Rgba32)]
         public void ThrowsNotSupported<TPixel>(TestImageProvider<TPixel> provider)
@@ -45,12 +37,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         [InlineData(RgbUncompressed, 24, 256, 256, 300, 300, PixelResolutionUnit.PixelsPerInch)]
         [InlineData(SmallRgbDeflate, 24, 32, 32, 96, 96, PixelResolutionUnit.PixelsPerInch)]
         [InlineData(Calliphora_GrayscaleUncompressed, 8, 804, 1198, 96, 96, PixelResolutionUnit.PixelsPerInch)]
+        [InlineData(Flower4BitPalette, 4, 73, 43, 72, 72, PixelResolutionUnit.PixelsPerInch)]
         public void Identify(string imagePath, int expectedPixelSize, int expectedWidth, int expectedHeight, double expectedHResolution, double expectedVResolution, PixelResolutionUnit expectedResolutionUnit)
         {
             var testFile = TestFile.Create(imagePath);
             using (var stream = new MemoryStream(testFile.Bytes, false))
             {
-                IImageInfo info = Image.Identify(this.configuration, stream);
+                IImageInfo info = Image.Identify(stream);
 
                 Assert.Equal(expectedPixelSize, info.PixelType?.BitsPerPixel);
                 Assert.Equal(expectedWidth, info.Width);
@@ -70,14 +63,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             var testFile = TestFile.Create(imagePath);
             using (var stream = new MemoryStream(testFile.Bytes, false))
             {
-                IImageInfo info = Image.Identify(this.configuration, stream);
+                IImageInfo info = Image.Identify(stream);
 
                 Assert.NotNull(info.Metadata);
                 Assert.Equal(expectedByteOrder, info.Metadata.GetTiffMetadata().ByteOrder);
 
                 stream.Seek(0, SeekOrigin.Begin);
 
-                using var img = Image.Load(this.configuration, stream);
+                using var img = Image.Load(stream);
                 Assert.Equal(expectedByteOrder, img.Metadata.GetTiffMetadata().ByteOrder);
             }
         }
@@ -99,6 +92,37 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         public void TiffDecoder_CanDecode_WithPalette<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
 
+        [Theory]
+        [WithFile(Rgb4BitPalette, PixelTypes.Rgba32)]
+        [WithFile(Flower4BitPalette, PixelTypes.Rgba32)]
+        [WithFile(Flower4BitPaletteGray, PixelTypes.Rgba32)]
+        public void TiffDecoder_CanDecode_4Bit_WithPalette<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider, ReferenceDecoder, useExactComparer: false, 0.01f);
+
+        [Theory]
+        [WithFile(FlowerRgb222Contiguous, PixelTypes.Rgba32)]
+        [WithFile(FlowerRgb222Planar, PixelTypes.Rgba32)]
+        public void TiffDecoder_CanDecode_6Bit<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
+
+        [Theory]
+        [WithFile(FlowerRgb444Contiguous, PixelTypes.Rgba32)]
+        [WithFile(FlowerRgb444Planar, PixelTypes.Rgba32)]
+        public void TiffDecoder_CanDecode_12Bit<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
+
+        [Theory]
+        [WithFile(FlowerRgb101010Contiguous, PixelTypes.Rgba32)]
+        [WithFile(FlowerRgb101010Planar, PixelTypes.Rgba32)]
+        public void TiffDecoder_CanDecode_30Bit<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
+
+        [Theory]
+        [WithFile(FlowerRgb141414Contiguous, PixelTypes.Rgba32)]
+        [WithFile(FlowerRgb141414Planar, PixelTypes.Rgba32)]
+        public void TiffDecoder_CanDecode_42Bit<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
+
         [Theory]
         [WithFile(GrayscaleDeflateMultistrip, PixelTypes.Rgba32)]
         [WithFile(RgbDeflateMultistrip, PixelTypes.Rgba32)]
@@ -163,12 +187,15 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             image.CompareToOriginalMultiFrame(provider, ImageComparer.Exact, ReferenceDecoder);
         }
 
-        private static void TestTiffDecoder<TPixel>(TestImageProvider<TPixel> provider)
+        private static void TestTiffDecoder<TPixel>(TestImageProvider<TPixel> provider, IImageDecoder referenceDecoder = null, bool useExactComparer = true, float compareTolerance = 0.001f)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             using Image<TPixel> image = provider.GetImage(TiffDecoder);
             image.DebugSave(provider);
-            image.CompareToOriginal(provider, ImageComparer.Exact, ReferenceDecoder);
+            image.CompareToOriginal(
+                provider,
+                useExactComparer ? ImageComparer.Exact : ImageComparer.Tolerant(compareTolerance),
+                referenceDecoder ?? ReferenceDecoder);
         }
     }
 }

tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs

@@ -22,14 +22,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
     {
         private static readonly IImageDecoder ReferenceDecoder = new MagickReferenceDecoder();
 
-        private static readonly Configuration Configuration;
-
-        static TiffEncoderTests()
-        {
-            Configuration = new Configuration();
-            Configuration.AddTiff();
-        }
-
         [Theory]
         [InlineData(null, TiffBitsPerPixel.Bit24)]
         [InlineData(TiffPhotometricInterpretation.Rgb, TiffBitsPerPixel.Bit24)]
@@ -55,7 +47,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
             Assert.Equal(TiffCompression.None, frameMetaData.Compression);
@@ -78,13 +70,36 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
 
             TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(bitsPerPixel, frameMetaData.BitsPerPixel);
             Assert.Equal(TiffCompression.None, frameMetaData.Compression);
         }
 
+        [Theory]
+        [InlineData(TiffBitsPerPixel.Bit42)]
+        [InlineData(TiffBitsPerPixel.Bit30)]
+        [InlineData(TiffBitsPerPixel.Bit12)]
+        [InlineData(TiffBitsPerPixel.Bit6)]
+        public void EncoderOptions_UnsupportedBitPerPixel_DefaultTo24Bits(TiffBitsPerPixel bitsPerPixel)
+        {
+            // arrange
+            var tiffEncoder = new TiffEncoder { BitsPerPixel = bitsPerPixel };
+            using Image input = new Image<Rgb24>(10, 10);
+            using var memStream = new MemoryStream();
+
+            // act
+            input.Save(memStream, tiffEncoder);
+
+            // assert
+            memStream.Position = 0;
+            using var output = Image.Load<Rgba32>(memStream);
+
+            TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
+            Assert.Equal(TiffBitsPerPixel.Bit24, frameMetaData.BitsPerPixel);
+        }
+
         [Theory]
         [InlineData(null, TiffCompression.Deflate, TiffBitsPerPixel.Bit24, TiffCompression.Deflate)]
         [InlineData(TiffPhotometricInterpretation.Rgb, TiffCompression.Deflate, TiffBitsPerPixel.Bit24, TiffCompression.Deflate)]
@@ -117,7 +132,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             TiffFrameMetadata rootFrameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(expectedBitsPerPixel, rootFrameMetaData.BitsPerPixel);
             Assert.Equal(expectedCompression, rootFrameMetaData.Compression);
@@ -143,7 +158,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
         }
@@ -162,7 +177,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
         }
@@ -185,7 +200,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             Assert.Equal(expectedCompression, output.Frames.RootFrame.Metadata.GetTiffMetadata().Compression);
         }
 
@@ -207,7 +222,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             TiffFrameMetadata frameMetadata = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(expectedPredictor, frameMetadata.Predictor);
         }
@@ -230,12 +245,18 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(TiffBitsPerPixel.Bit1, frameMetaData.BitsPerPixel);
             Assert.Equal(expectedCompression, frameMetaData.Compression);
         }
 
+        // This makes sure, that when decoding a planar tiff, the planar configuration is not carried over to the encoded image.
+        [Theory]
+        [WithFile(FlowerRgb444Planar, PixelTypes.Rgba32)]
+        public void TiffEncoder_EncodePlanar_AndReload_Works<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel> => TestTiffEncoderCore(provider, TiffBitsPerPixel.Bit24, TiffPhotometricInterpretation.Rgb, imageDecoder: new TiffDecoder());
+
         [Theory]
         [WithFile(Calliphora_RgbUncompressed, PixelTypes.Rgba32)]
         public void TiffEncoder_EncodeRgb_Works<TPixel>(TestImageProvider<TPixel> provider)
@@ -304,10 +325,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
         [Theory]
         [WithFile(Rgb4BitPalette, PixelTypes.Rgba32)]
+        [WithFile(Flower4BitPalette, PixelTypes.Rgba32)]
+        [WithFile(Flower4BitPaletteGray, PixelTypes.Rgba32)]
         public void TiffEncoder_EncodeColorPalette_With4Bit_Works<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel> =>
-            //// Note: The magick reference decoder does not support 4 bit tiff's, so we use our TIFF decoder instead.
-            TestTiffEncoderCore(provider, TiffBitsPerPixel.Bit4, TiffPhotometricInterpretation.PaletteColor, useExactComparer: false, compareTolerance: 0.001f, imageDecoder: new TiffDecoder());
+            TestTiffEncoderCore(provider, TiffBitsPerPixel.Bit4, TiffPhotometricInterpretation.PaletteColor, useExactComparer: false, compareTolerance: 0.003f);
 
         [Theory]
         [WithFile(Calliphora_PaletteUncompressed, PixelTypes.Rgba32)]
@@ -422,7 +444,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // assert
             memStream.Position = 0;
-            using var output = Image.Load<Rgba32>(Configuration, memStream);
+            using var output = Image.Load<Rgba32>(memStream);
             ExifProfile exifProfileOutput = output.Frames.RootFrame.Metadata.ExifProfile;
             TiffFrameMetadata outputMeta = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             ImageFrame<Rgba32> rootFrame = output.Frames.RootFrame;
@@ -468,7 +490,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             TiffCompression compression = TiffCompression.None,
             TiffPredictor predictor = TiffPredictor.None,
             bool useExactComparer = true,
-            float compareTolerance = 0.01f,
+            float compareTolerance = 0.001f,
             IImageDecoder imageDecoder = null)
             where TPixel : unmanaged, IPixel<TPixel>
         {

tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs

@@ -20,16 +20,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
     [Trait("Format", "Tiff")]
     public class TiffMetadataTests
     {
-        private readonly Configuration configuration;
-
         private static TiffDecoder TiffDecoder => new TiffDecoder();
 
-        public TiffMetadataTests()
-        {
-            this.configuration = new Configuration();
-            this.configuration.AddTiff();
-        }
-
         [Fact]
         public void TiffMetadata_CloneIsDeep()
         {
@@ -89,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             var testFile = TestFile.Create(imagePath);
             using var stream = new MemoryStream(testFile.Bytes, false);
 
-            IImageInfo imageInfo = Image.Identify(this.configuration, stream);
+            IImageInfo imageInfo = Image.Identify(stream);
 
             Assert.NotNull(imageInfo);
             TiffMetadata tiffMetadata = imageInfo.Metadata.GetTiffMetadata();
@@ -105,7 +97,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             var testFile = TestFile.Create(imagePath);
             using var stream = new MemoryStream(testFile.Bytes, false);
 
-            IImageInfo imageInfo = Image.Identify(this.configuration, stream);
+            IImageInfo imageInfo = Image.Identify(stream);
 
             Assert.NotNull(imageInfo);
             TiffMetadata tiffMetadata = imageInfo.Metadata.GetTiffMetadata();
@@ -265,7 +257,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             // Assert
             ms.Position = 0;
-            using var encodedImage = Image.Load<Rgba32>(this.configuration, ms);
+            using var encodedImage = Image.Load<Rgba32>(ms);
 
             ImageMetadata encodedImageMetaData = encodedImage.Metadata;
             ImageFrame<Rgba32> rootFrameEncodedImage = encodedImage.Frames.RootFrame;
@@ -296,10 +288,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             Assert.Equal("This is Изготовитель камеры", exifProfileInput.GetValue(ExifTag.Make).Value);
             Assert.Equal("This is Авторские права", exifProfileInput.GetValue(ExifTag.Copyright).Value);
 
-            Assert.Equal(exifProfileInput.Values.Count, encodedImageExifProfile.Values.Count);
             Assert.Equal(exifProfileInput.GetValue(ExifTag.ImageDescription).Value, encodedImageExifProfile.GetValue(ExifTag.ImageDescription).Value);
             Assert.Equal(exifProfileInput.GetValue(ExifTag.Make).Value, encodedImageExifProfile.GetValue(ExifTag.Make).Value);
             Assert.Equal(exifProfileInput.GetValue(ExifTag.Copyright).Value, encodedImageExifProfile.GetValue(ExifTag.Copyright).Value);
+
+            // Note that the encoded profile has PlanarConfiguration explicitly set, which is missing in the original image profile.
+            Assert.Equal((ushort)TiffPlanarConfiguration.Chunky, encodedImageExifProfile.GetValue(ExifTag.PlanarConfiguration)?.Value);
+            Assert.Equal(exifProfileInput.Values.Count + 1, encodedImageExifProfile.Values.Count);
         }
     }
 }

tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs

@@ -28,7 +28,8 @@ namespace SixLabors.ImageSharp.Tests
                 ArgumentException ex = Assert.Throws<ArgumentException>(
                     () =>
                     {
-                        this.Collection.AddFrame(new ImageFrame<Rgba32>(Configuration.Default, 1, 1));
+                        using var frame = new ImageFrame<Rgba32>(Configuration.Default, 1, 1);
+                        using ImageFrame<Rgba32> addedFrame = this.Collection.AddFrame(frame);
                     });
 
                 Assert.StartsWith("Frame must have the same dimensions as the image.", ex.Message);
@@ -40,7 +41,7 @@ namespace SixLabors.ImageSharp.Tests
                 ArgumentNullException ex = Assert.Throws<ArgumentNullException>(
                     () =>
                     {
-                        this.Collection.AddFrame((ImageFrame<Rgba32>)null);
+                        using ImageFrame<Rgba32> addedFrame = this.Collection.AddFrame((ImageFrame<Rgba32>)null);
                     });
 
                 Assert.StartsWith("Parameter \"frame\" must be not null.", ex.Message);
@@ -54,7 +55,7 @@ namespace SixLabors.ImageSharp.Tests
                 ArgumentNullException ex = Assert.Throws<ArgumentNullException>(
                     () =>
                     {
-                        this.Collection.AddFrame(data);
+                        using ImageFrame<Rgba32> addedFrame = this.Collection.AddFrame(data);
                     });
 
                 Assert.StartsWith("Parameter \"source\" must be not null.", ex.Message);
@@ -66,7 +67,7 @@ namespace SixLabors.ImageSharp.Tests
                 ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(
                     () =>
                     {
-                        this.Collection.AddFrame(new Rgba32[0]);
+                        using ImageFrame<Rgba32> addedFrame = this.Collection.AddFrame(Array.Empty<Rgba32>());
                     });
 
                 Assert.StartsWith($"Parameter \"data\" ({typeof(int)}) must be greater than or equal to {100}, was {0}", ex.Message);
@@ -78,7 +79,8 @@ namespace SixLabors.ImageSharp.Tests
                 ArgumentException ex = Assert.Throws<ArgumentException>(
                     () =>
                     {
-                        this.Collection.InsertFrame(1, new ImageFrame<Rgba32>(Configuration.Default, 1, 1));
+                        using var frame = new ImageFrame<Rgba32>(Configuration.Default, 1, 1);
+                        using ImageFrame<Rgba32> insertedFrame = this.Collection.InsertFrame(1, frame);
                     });
 
                 Assert.StartsWith("Frame must have the same dimensions as the image.", ex.Message);
@@ -90,7 +92,7 @@ namespace SixLabors.ImageSharp.Tests
                 ArgumentNullException ex = Assert.Throws<ArgumentNullException>(
                     () =>
                     {
-                        this.Collection.InsertFrame(1, null);
+                        using ImageFrame<Rgba32> insertedFrame = this.Collection.InsertFrame(1, null);
                     });
 
                 Assert.StartsWith("Parameter \"frame\" must be not null.", ex.Message);
@@ -102,9 +104,11 @@ namespace SixLabors.ImageSharp.Tests
                 ArgumentException ex = Assert.Throws<ArgumentException>(
                     () =>
                     {
+                        using var imageFrame1 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                        using var imageFrame2 = new ImageFrame<Rgba32>(Configuration.Default, 1, 1);
                         new ImageFrameCollection<Rgba32>(
                             this.Image,
-                            new[] { new ImageFrame<Rgba32>(Configuration.Default, 10, 10), new ImageFrame<Rgba32>(Configuration.Default, 1, 1) });
+                            new[] { imageFrame1, imageFrame2 });
                     });
 
                 Assert.StartsWith("Frame must have the same dimensions as the image.", ex.Message);
@@ -113,24 +117,24 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void RemoveAtFrame_ThrowIfRemovingLastFrame()
             {
+                using var imageFrame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
                 var collection = new ImageFrameCollection<Rgba32>(
                     this.Image,
-                    new[] { new ImageFrame<Rgba32>(Configuration.Default, 10, 10) });
+                    new[] { imageFrame });
 
                 InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
-                    () =>
-                    {
-                        collection.RemoveFrame(0);
-                    });
+                    () => collection.RemoveFrame(0));
                 Assert.Equal("Cannot remove last frame.", ex.Message);
             }
 
             [Fact]
             public void RemoveAtFrame_CanRemoveFrameZeroIfMultipleFramesExist()
             {
+                using var imageFrame1 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using var imageFrame2 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
                 var collection = new ImageFrameCollection<Rgba32>(
                     this.Image,
-                    new[] { new ImageFrame<Rgba32>(Configuration.Default, 10, 10), new ImageFrame<Rgba32>(Configuration.Default, 10, 10) });
+                    new[] { imageFrame1, imageFrame2 });
 
                 collection.RemoveFrame(0);
                 Assert.Equal(1, collection.Count);
@@ -139,9 +143,11 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void RootFrameIsFrameAtIndexZero()
             {
+                using var imageFrame1 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using var imageFrame2 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
                 var collection = new ImageFrameCollection<Rgba32>(
                     this.Image,
-                    new[] { new ImageFrame<Rgba32>(Configuration.Default, 10, 10), new ImageFrame<Rgba32>(Configuration.Default, 10, 10) });
+                    new[] { imageFrame1, imageFrame2 });
 
                 Assert.Equal(collection.RootFrame, collection[0]);
             }
@@ -149,9 +155,11 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void ConstructorPopulatesFrames()
             {
+                using var imageFrame1 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using var imageFrame2 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
                 var collection = new ImageFrameCollection<Rgba32>(
                     this.Image,
-                    new[] { new ImageFrame<Rgba32>(Configuration.Default, 10, 10), new ImageFrame<Rgba32>(Configuration.Default, 10, 10) });
+                    new[] { imageFrame1, imageFrame2 });
 
                 Assert.Equal(2, collection.Count);
             }
@@ -159,9 +167,11 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void DisposeClearsCollection()
             {
+                using var imageFrame1 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using var imageFrame2 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
                 var collection = new ImageFrameCollection<Rgba32>(
                     this.Image,
-                    new[] { new ImageFrame<Rgba32>(Configuration.Default, 10, 10), new ImageFrame<Rgba32>(Configuration.Default, 10, 10) });
+                    new[] { imageFrame1, imageFrame2 });
 
                 collection.Dispose();
 
@@ -171,9 +181,11 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void Dispose_DisposesAllInnerFrames()
             {
+                using var imageFrame1 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using var imageFrame2 = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
                 var collection = new ImageFrameCollection<Rgba32>(
                     this.Image,
-                    new[] { new ImageFrame<Rgba32>(Configuration.Default, 10, 10), new ImageFrame<Rgba32>(Configuration.Default, 10, 10) });
+                    new[] { imageFrame1, imageFrame2 });
 
                 IPixelSource<Rgba32>[] framesSnapShot = collection.OfType<IPixelSource<Rgba32>>().ToArray();
                 collection.Dispose();
@@ -194,7 +206,8 @@ namespace SixLabors.ImageSharp.Tests
             {
                 using (Image<TPixel> img = provider.GetImage())
                 {
-                    img.Frames.AddFrame(new ImageFrame<TPixel>(Configuration.Default, 10, 10)); // add a frame anyway
+                    using var imageFrame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                    using ImageFrame addedFrame = img.Frames.AddFrame(imageFrame); // add a frame anyway
                     using (Image<TPixel> cloned = img.Frames.CloneFrame(0))
                     {
                         Assert.Equal(2, img.Frames.Count);
@@ -215,7 +228,8 @@ namespace SixLabors.ImageSharp.Tests
                     Assert.True(img.TryGetSinglePixelSpan(out Span<TPixel> imgSpan));
                     TPixel[] sourcePixelData = imgSpan.ToArray();
 
-                    img.Frames.AddFrame(new ImageFrame<TPixel>(Configuration.Default, 10, 10));
+                    using var imageFrame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                    using ImageFrame addedFrame = img.Frames.AddFrame(imageFrame);
                     using (Image<TPixel> cloned = img.Frames.ExportFrame(0))
                     {
                         Assert.Equal(1, img.Frames.Count);
@@ -227,35 +241,37 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void CreateFrame_Default()
             {
-                this.Image.Frames.CreateFrame();
-
-                Assert.Equal(2, this.Image.Frames.Count);
-                this.Image.Frames[1].ComparePixelBufferTo(default(Rgba32));
+                using (this.Image.Frames.CreateFrame())
+                {
+                    Assert.Equal(2, this.Image.Frames.Count);
+                    this.Image.Frames[1].ComparePixelBufferTo(default(Rgba32));
+                }
             }
 
             [Fact]
             public void CreateFrame_CustomFillColor()
             {
-                this.Image.Frames.CreateFrame(Color.HotPink);
-
-                Assert.Equal(2, this.Image.Frames.Count);
-                this.Image.Frames[1].ComparePixelBufferTo(Color.HotPink);
+                using (this.Image.Frames.CreateFrame(Color.HotPink))
+                {
+                    Assert.Equal(2, this.Image.Frames.Count);
+                    this.Image.Frames[1].ComparePixelBufferTo(Color.HotPink);
+                }
             }
 
             [Fact]
             public void AddFrameFromPixelData()
             {
                 Assert.True(this.Image.Frames.RootFrame.TryGetSinglePixelSpan(out Span<Rgba32> imgSpan));
-                var pixelData = imgSpan.ToArray();
-                this.Image.Frames.AddFrame(pixelData);
+                Rgba32[] pixelData = imgSpan.ToArray();
+                using ImageFrame<Rgba32> addedFrame = this.Image.Frames.AddFrame(pixelData);
                 Assert.Equal(2, this.Image.Frames.Count);
             }
 
             [Fact]
             public void AddFrame_clones_sourceFrame()
             {
-                var otherFrame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
-                ImageFrame<Rgba32> addedFrame = this.Image.Frames.AddFrame(otherFrame);
+                using var otherFrame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using ImageFrame<Rgba32> addedFrame = this.Image.Frames.AddFrame(otherFrame);
 
                 Assert.True(otherFrame.TryGetSinglePixelSpan(out Span<Rgba32> otherFrameSpan));
                 addedFrame.ComparePixelBufferTo(otherFrameSpan);
@@ -265,8 +281,8 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void InsertFrame_clones_sourceFrame()
             {
-                var otherFrame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
-                ImageFrame<Rgba32> addedFrame = this.Image.Frames.InsertFrame(0, otherFrame);
+                using var otherFrame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using ImageFrame<Rgba32> addedFrame = this.Image.Frames.InsertFrame(0, otherFrame);
 
                 Assert.True(otherFrame.TryGetSinglePixelSpan(out Span<Rgba32> otherFrameSpan));
                 addedFrame.ComparePixelBufferTo(otherFrameSpan);
@@ -276,53 +292,95 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void MoveFrame_LeavesFrameInCorrectLocation()
             {
-                for (var i = 0; i < 9; i++)
+                for (int i = 0; i < 9; i++)
                 {
                     this.Image.Frames.CreateFrame();
                 }
 
-                var frame = this.Image.Frames[4];
+                ImageFrame<Rgba32> frame = this.Image.Frames[4];
                 this.Image.Frames.MoveFrame(4, 7);
-                var newIndex = this.Image.Frames.IndexOf(frame);
+                int newIndex = this.Image.Frames.IndexOf(frame);
                 Assert.Equal(7, newIndex);
             }
 
             [Fact]
             public void IndexOf_ReturnsCorrectIndex()
             {
-                for (var i = 0; i < 9; i++)
+                for (int i = 0; i < 9; i++)
                 {
                     this.Image.Frames.CreateFrame();
                 }
 
-                var frame = this.Image.Frames[4];
-                var index = this.Image.Frames.IndexOf(frame);
+                ImageFrame<Rgba32> frame = this.Image.Frames[4];
+                int index = this.Image.Frames.IndexOf(frame);
                 Assert.Equal(4, index);
             }
 
             [Fact]
             public void Contains_TrueIfMember()
             {
-                for (var i = 0; i < 9; i++)
+                for (int i = 0; i < 9; i++)
                 {
                     this.Image.Frames.CreateFrame();
                 }
 
-                var frame = this.Image.Frames[4];
+                ImageFrame<Rgba32> frame = this.Image.Frames[4];
                 Assert.True(this.Image.Frames.Contains(frame));
             }
 
             [Fact]
             public void Contains_FalseIfNonMember()
             {
-                for (var i = 0; i < 9; i++)
+                for (int i = 0; i < 9; i++)
                 {
                     this.Image.Frames.CreateFrame();
                 }
 
-                var frame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
+                using var frame = new ImageFrame<Rgba32>(Configuration.Default, 10, 10);
                 Assert.False(this.Image.Frames.Contains(frame));
             }
+
+            [Fact]
+            public void DisposeCall_NoThrowIfCalledMultiple()
+            {
+                var image = new Image<Rgba32>(Configuration.Default, 10, 10);
+                var frameCollection = image.Frames as ImageFrameCollection;
+
+                image.Dispose(); // this should invalidate underlying collection as well
+                frameCollection.Dispose();
+            }
+
+            [Fact]
+            public void PublicProperties_ThrowIfDisposed()
+            {
+                var image = new Image<Rgba32>(Configuration.Default, 10, 10);
+                var frameCollection = image.Frames as ImageFrameCollection;
+
+                image.Dispose(); // this should invalidate underlying collection as well
+
+                Assert.Throws<ObjectDisposedException>(() => { var prop = frameCollection.RootFrame; });
+            }
+
+            [Fact]
+            public void PublicMethods_ThrowIfDisposed()
+            {
+                var image = new Image<Rgba32>(Configuration.Default, 10, 10);
+                var frameCollection = image.Frames as ImageFrameCollection;
+
+                image.Dispose(); // this should invalidate underlying collection as well
+
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.AddFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.CloneFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.Contains(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.CreateFrame(); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.CreateFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.ExportFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.GetEnumerator(); });
+                Assert.Throws<ObjectDisposedException>(() => { var prop = frameCollection.IndexOf(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var prop = frameCollection.InsertFrame(default, default); });
+                Assert.Throws<ObjectDisposedException>(() => { frameCollection.RemoveFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { frameCollection.MoveFrame(default, default); });
+            }
         }
     }
 }

tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs

@@ -263,6 +263,42 @@ namespace SixLabors.ImageSharp.Tests
                 Assert.False(this.Image.Frames.Contains(frame));
             }
 
+            [Fact]
+            public void PublicProperties_ThrowIfDisposed()
+            {
+                var image = new Image<Rgba32>(Configuration.Default, 10, 10);
+                var frameCollection = image.Frames;
+
+                image.Dispose(); // this should invalidate underlying collection as well
+
+                Assert.Throws<ObjectDisposedException>(() => { var prop = frameCollection.RootFrame; });
+            }
+
+            [Fact]
+            public void PublicMethods_ThrowIfDisposed()
+            {
+                var image = new Image<Rgba32>(Configuration.Default, 10, 10);
+                var frameCollection = image.Frames;
+                var rgba32Array = new Rgba32[0];
+
+                image.Dispose(); // this should invalidate underlying collection as well
+
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.AddFrame((ImageFrame)null); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.AddFrame(rgba32Array); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.AddFrame((ImageFrame<Rgba32>)null); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.AddFrame(rgba32Array.AsSpan()); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.CloneFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.Contains(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.CreateFrame(); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.CreateFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.ExportFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = frameCollection.GetEnumerator(); });
+                Assert.Throws<ObjectDisposedException>(() => { var prop = frameCollection.IndexOf(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var prop = frameCollection.InsertFrame(default, default); });
+                Assert.Throws<ObjectDisposedException>(() => { frameCollection.RemoveFrame(default); });
+                Assert.Throws<ObjectDisposedException>(() => { frameCollection.MoveFrame(default, default); });
+            }
+
             /// <summary>
             /// Integration test for end-to end API validation.
             /// </summary>

tests/ImageSharp.Tests/Image/ImageTests.Identify.cs

@@ -21,7 +21,7 @@ namespace SixLabors.ImageSharp.Tests
 
             private static readonly Size ExpectedImageSize = new Size(108, 202);
 
-            private byte[] ActualImageBytes => TestFile.Create(TestImages.Bmp.F).Bytes;
+            private static byte[] ActualImageBytes => TestFile.Create(TestImages.Bmp.F).Bytes;
 
             private IImageInfo LocalImageInfo => this.localImageInfoMock.Object;
 
@@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void FromBytes_GlobalConfiguration()
             {
-                IImageInfo info = Image.Identify(this.ActualImageBytes, out IImageFormat type);
+                IImageInfo info = Image.Identify(ActualImageBytes, out IImageFormat type);
 
                 Assert.Equal(ExpectedImageSize, info.Size());
                 Assert.Equal(ExpectedGlobalFormat, type);
@@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void FromStream_GlobalConfiguration()
             {
-                using (var stream = new MemoryStream(this.ActualImageBytes))
+                using (var stream = new MemoryStream(ActualImageBytes))
                 {
                     IImageInfo info = Image.Identify(stream, out IImageFormat type);
 
@@ -81,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void FromStream_GlobalConfiguration_NoFormat()
             {
-                using (var stream = new MemoryStream(this.ActualImageBytes))
+                using (var stream = new MemoryStream(ActualImageBytes))
                 {
                     IImageInfo info = Image.Identify(stream);
 
@@ -92,7 +92,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void FromNonSeekableStream_GlobalConfiguration()
             {
-                using var stream = new MemoryStream(this.ActualImageBytes);
+                using var stream = new MemoryStream(ActualImageBytes);
                 using var nonSeekableStream = new NonSeekableStream(stream);
 
                 IImageInfo info = Image.Identify(nonSeekableStream, out IImageFormat type);
@@ -104,7 +104,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void FromNonSeekableStream_GlobalConfiguration_NoFormat()
             {
-                using var stream = new MemoryStream(this.ActualImageBytes);
+                using var stream = new MemoryStream(ActualImageBytes);
                 using var nonSeekableStream = new NonSeekableStream(stream);
 
                 IImageInfo info = Image.Identify(nonSeekableStream);
@@ -141,7 +141,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public async Task FromStreamAsync_GlobalConfiguration_NoFormat()
             {
-                using (var stream = new MemoryStream(this.ActualImageBytes))
+                using (var stream = new MemoryStream(ActualImageBytes))
                 {
                     var asyncStream = new AsyncStreamWrapper(stream, () => false);
                     IImageInfo info = await Image.IdentifyAsync(asyncStream);
@@ -153,7 +153,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public async Task FromStreamAsync_GlobalConfiguration()
             {
-                using (var stream = new MemoryStream(this.ActualImageBytes))
+                using (var stream = new MemoryStream(ActualImageBytes))
                 {
                     var asyncStream = new AsyncStreamWrapper(stream, () => false);
                     (IImageInfo ImageInfo, IImageFormat Format) res = await Image.IdentifyWithFormatAsync(asyncStream);
@@ -166,7 +166,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public async Task FromNonSeekableStreamAsync_GlobalConfiguration_NoFormat()
             {
-                using var stream = new MemoryStream(this.ActualImageBytes);
+                using var stream = new MemoryStream(ActualImageBytes);
                 using var nonSeekableStream = new NonSeekableStream(stream);
 
                 var asyncStream = new AsyncStreamWrapper(nonSeekableStream, () => false);
@@ -178,7 +178,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public async Task FromNonSeekableStreamAsync_GlobalConfiguration()
             {
-                using var stream = new MemoryStream(this.ActualImageBytes);
+                using var stream = new MemoryStream(ActualImageBytes);
                 using var nonSeekableStream = new NonSeekableStream(stream);
 
                 var asyncStream = new AsyncStreamWrapper(nonSeekableStream, () => false);

tests/ImageSharp.Tests/Image/ImageTests.Save.cs

@@ -3,9 +3,8 @@
 
 using System;
 using System.IO;
-
 using Moq;
-
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
@@ -13,8 +12,6 @@ using Xunit;
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Tests
 {
-    using SixLabors.ImageSharp.Formats;
-
     public partial class ImageTests
     {
         public class Save
@@ -23,7 +20,7 @@ namespace SixLabors.ImageSharp.Tests
             public void DetectedEncoding()
             {
                 string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests));
-                string file = System.IO.Path.Combine(dir, "DetectedEncoding.png");
+                string file = Path.Combine(dir, "DetectedEncoding.png");
 
                 using (var image = new Image<Rgba32>(10, 10))
                 {
@@ -40,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests
             public void WhenExtensionIsUnknown_Throws()
             {
                 string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests));
-                string file = System.IO.Path.Combine(dir, "UnknownExtensionsEncoding_Throws.tmp");
+                string file = Path.Combine(dir, "UnknownExtensionsEncoding_Throws.tmp");
 
                 Assert.Throws<NotSupportedException>(
                     () =>
@@ -56,14 +53,14 @@ namespace SixLabors.ImageSharp.Tests
             public void SetEncoding()
             {
                 string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests));
-                string file = System.IO.Path.Combine(dir, "SetEncoding.dat");
+                string file = Path.Combine(dir, "SetEncoding.dat");
 
                 using (var image = new Image<Rgba32>(10, 10))
                 {
                     image.Save(file, new PngEncoder());
                 }
 
-                using (Image.Load(file, out var mime))
+                using (Image.Load(file, out IImageFormat mime))
                 {
                     Assert.Equal("image/png", mime.DefaultMimeType);
                 }
@@ -72,7 +69,7 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void ThrowsWhenDisposed()
             {
-                var image = new Image<Rgba32>(5, 5);
+                using var image = new Image<Rgba32>(5, 5);
                 image.Dispose();
                 IImageEncoder encoder = Mock.Of<IImageEncoder>();
                 using (var stream = new MemoryStream())

tests/ImageSharp.Tests/Image/ImageTests.SaveAsync.cs

@@ -4,20 +4,18 @@
 using System;
 using System.IO;
 using System.Threading;
+using System.Threading.Tasks;
 using Moq;
-using SixLabors.ImageSharp.Formats.Bmp;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using Xunit;
 
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Tests
 {
-    using System.Threading.Tasks;
-    using SixLabors.ImageSharp.Advanced;
-    using SixLabors.ImageSharp.Formats;
-    using SixLabors.ImageSharp.Tests.TestUtilities;
-
     public partial class ImageTests
     {
         public class SaveAsync
@@ -43,7 +41,7 @@ namespace SixLabors.ImageSharp.Tests
             public async Task WhenExtensionIsUnknown_Throws()
             {
                 string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests));
-                string file = System.IO.Path.Combine(dir, "UnknownExtensionsEncoding_Throws.tmp");
+                string file = Path.Combine(dir, "UnknownExtensionsEncoding_Throws.tmp");
 
                 await Assert.ThrowsAsync<NotSupportedException>(
                     async () =>
@@ -59,14 +57,14 @@ namespace SixLabors.ImageSharp.Tests
             public async Task SetEncoding()
             {
                 string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests));
-                string file = System.IO.Path.Combine(dir, "SetEncoding.dat");
+                string file = Path.Combine(dir, "SetEncoding.dat");
 
                 using (var image = new Image<Rgba32>(10, 10))
                 {
                     await image.SaveAsync(file, new PngEncoder());
                 }
 
-                using (Image.Load(file, out var mime))
+                using (Image.Load(file, out IImageFormat mime))
                 {
                     Assert.Equal("image/png", mime.DefaultMimeType);
                 }
@@ -142,10 +140,15 @@ namespace SixLabors.ImageSharp.Tests
                 using var stream = new MemoryStream();
                 var asyncStream = new AsyncStreamWrapper(stream, () => false);
                 var cts = new CancellationTokenSource();
-                cts.CancelAfter(TimeSpan.FromTicks(1));
 
-                await Assert.ThrowsAnyAsync<TaskCanceledException>(() =>
-                    image.SaveAsync(asyncStream, encoder, cts.Token));
+                var pausedStream = new PausedStream(asyncStream);
+                pausedStream.OnWaiting(s =>
+                {
+                    cts.Cancel();
+                    pausedStream.Release();
+                });
+
+                await Assert.ThrowsAsync<TaskCanceledException>(async () => await image.SaveAsync(pausedStream, encoder, cts.Token));
             }
         }
     }

tests/ImageSharp.Tests/Image/ImageTests.cs

@@ -2,7 +2,9 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.IO;
 using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
@@ -169,5 +171,72 @@ namespace SixLabors.ImageSharp.Tests
                 Assert.Equal("y", ex.ParamName);
             }
         }
+
+        public class Dispose
+        {
+            private readonly Configuration configuration = Configuration.CreateDefaultInstance();
+
+            public void MultipleDisposeCalls()
+            {
+                var image = new Image<Rgba32>(this.configuration, 10, 10);
+                image.Dispose();
+                image.Dispose();
+            }
+
+            [Fact]
+            public void NonPrivateProperties_ObjectDisposedException()
+            {
+                var image = new Image<Rgba32>(this.configuration, 10, 10);
+                var genericImage = (Image)image;
+
+                image.Dispose();
+
+                // Image<TPixel>
+                Assert.Throws<ObjectDisposedException>(() => { var prop = image.Frames; });
+
+                // Image
+                Assert.Throws<ObjectDisposedException>(() => { var prop = genericImage.Frames; });
+            }
+
+            [Fact]
+            public void Save_ObjectDisposedException()
+            {
+                using var stream = new MemoryStream();
+                var image = new Image<Rgba32>(this.configuration, 10, 10);
+                var encoder = new JpegEncoder();
+
+                image.Dispose();
+
+                // Image<TPixel>
+                Assert.Throws<ObjectDisposedException>(() => image.Save(stream, encoder));
+            }
+
+            [Fact]
+            public void AcceptVisitor_ObjectDisposedException()
+            {
+                // This test technically should exist but it's impossible to write proper test case without reflection:
+                // All visitor types are private and can't be created without context of some save/processing operation
+                // Save_ObjectDisposedException test checks this method with AcceptVisitor(EncodeVisitor) anyway
+                return;
+            }
+
+            [Fact]
+            public void NonPrivateMethods_ObjectDisposedException()
+            {
+                var image = new Image<Rgba32>(this.configuration, 10, 10);
+                var genericImage = (Image)image;
+
+                image.Dispose();
+
+                // Image<TPixel>
+                Assert.Throws<ObjectDisposedException>(() => { var res = image.Clone(this.configuration); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = image.CloneAs<Rgba32>(this.configuration); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = image.GetPixelRowSpan(default); });
+                Assert.Throws<ObjectDisposedException>(() => { var res = image.TryGetSinglePixelSpan(out var _); });
+
+                // Image
+                Assert.Throws<ObjectDisposedException>(() => { var res = genericImage.CloneAs<Rgba32>(this.configuration); });
+            }
+        }
     }
 }

tests/ImageSharp.Tests/Memory/Allocators/BufferTestSuite.cs

@@ -60,24 +60,24 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
             }
         }
 
-        public static readonly TheoryData<int> LenthValues = new TheoryData<int> { 0, 1, 7, 1023, 1024 };
+        public static readonly TheoryData<int> LengthValues = new TheoryData<int> { 0, 1, 7, 1023, 1024 };
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void HasCorrectLength_byte(int desiredLength)
         {
             this.TestHasCorrectLength<byte>(desiredLength);
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void HasCorrectLength_float(int desiredLength)
         {
             this.TestHasCorrectLength<float>(desiredLength);
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void HasCorrectLength_CustomStruct(int desiredLength)
         {
             this.TestHasCorrectLength<CustomStruct>(desiredLength);
@@ -93,7 +93,7 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void CanAllocateCleanBuffer_byte(int desiredLength)
         {
             this.TestCanAllocateCleanBuffer<byte>(desiredLength, false);
@@ -101,14 +101,14 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void CanAllocateCleanBuffer_double(int desiredLength)
         {
             this.TestCanAllocateCleanBuffer<double>(desiredLength);
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void CanAllocateCleanBuffer_CustomStruct(int desiredLength)
         {
             this.TestCanAllocateCleanBuffer<CustomStruct>(desiredLength);
@@ -145,14 +145,14 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void SpanPropertyIsAlwaysTheSame_int(int desiredLength)
         {
             this.TestSpanPropertyIsAlwaysTheSame<int>(desiredLength);
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void SpanPropertyIsAlwaysTheSame_byte(int desiredLength)
         {
             this.TestSpanPropertyIsAlwaysTheSame<byte>(desiredLength, false);
@@ -174,18 +174,18 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void WriteAndReadElements_float(int desiredLength)
         {
-            this.TestWriteAndReadElements<float>(desiredLength, x => x * 1.2f);
+            this.TestWriteAndReadElements(desiredLength, x => x * 1.2f);
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void WriteAndReadElements_byte(int desiredLength)
         {
-            this.TestWriteAndReadElements<byte>(desiredLength, x => (byte)(x + 1), false);
-            this.TestWriteAndReadElements<byte>(desiredLength, x => (byte)(x + 1), true);
+            this.TestWriteAndReadElements(desiredLength, x => (byte)(x + 1), false);
+            this.TestWriteAndReadElements(desiredLength, x => (byte)(x + 1), true);
         }
 
         private void TestWriteAndReadElements<T>(int desiredLength, Func<int, T> getExpectedValue, bool testManagedByteBuffer = false)
@@ -193,7 +193,7 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
         {
             using (IMemoryOwner<T> buffer = this.Allocate<T>(desiredLength, AllocationOptions.None, testManagedByteBuffer))
             {
-                T[] expectedVals = new T[buffer.Length()];
+                var expectedVals = new T[buffer.Length()];
 
                 for (int i = 0; i < buffer.Length(); i++)
                 {
@@ -211,7 +211,7 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void IndexingSpan_WhenOutOfRange_Throws_byte(int desiredLength)
         {
             this.TestIndexOutOfRangeShouldThrow<byte>(desiredLength, false);
@@ -219,14 +219,14 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void IndexingSpan_WhenOutOfRange_Throws_long(int desiredLength)
         {
             this.TestIndexOutOfRangeShouldThrow<long>(desiredLength);
         }
 
         [Theory]
-        [MemberData(nameof(LenthValues))]
+        [MemberData(nameof(LengthValues))]
         public void IndexingSpan_WhenOutOfRange_Throws_CustomStruct(int desiredLength)
         {
             this.TestIndexOutOfRangeShouldThrow<CustomStruct>(desiredLength);
@@ -316,4 +316,4 @@ namespace SixLabors.ImageSharp.Tests.Memory.Allocators
             }
         }
     }
-}
+}

tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifProfileTests.cs

@@ -12,7 +12,7 @@ using SixLabors.ImageSharp.PixelFormats;
 
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Exif
 {
     [Trait("Profile", "Exif")]
     public class ExifProfileTests
@@ -63,6 +63,7 @@ namespace SixLabors.ImageSharp.Tests
 
             Assert.NotNull(value);
             Assert.Equal(expected, value.Value);
+            image.Dispose();
         }
 
         [Fact]
@@ -157,6 +158,8 @@ namespace SixLabors.ImageSharp.Tests
             IExifValue<Rational> value2 = image.Metadata.ExifProfile.GetValue(ExifTag.FlashEnergy);
             Assert.NotNull(value2);
             Assert.Equal(new Rational(double.PositiveInfinity), value2.Value);
+
+            image.Dispose();
         }
 
         [Theory]
@@ -231,6 +234,8 @@ namespace SixLabors.ImageSharp.Tests
 
             latitude = image.Metadata.ExifProfile.GetValue(ExifTag.GPSLatitude);
             Assert.Equal(expectedLatitude, latitude.Value);
+
+            image.Dispose();
         }
 
         [Theory]
@@ -252,13 +257,15 @@ namespace SixLabors.ImageSharp.Tests
             {
                 Assert.True(ExifTags.GetPart(exifProfileValue.Tag) == ExifParts.ExifTags);
             }
+
+            image.Dispose();
         }
 
         [Fact]
         public void RemoveEntry_Works()
         {
             // Arrange
-            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
+            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
             int profileCount = image.Metadata.ExifProfile.Values.Count;
 
             // Assert
@@ -311,7 +318,7 @@ namespace SixLabors.ImageSharp.Tests
 
             TestProfile(profile);
 
-            Image<Rgba32> thumbnail = profile.CreateThumbnail<Rgba32>();
+            using Image<Rgba32> thumbnail = profile.CreateThumbnail<Rgba32>();
             Assert.NotNull(thumbnail);
             Assert.Equal(256, thumbnail.Width);
             Assert.Equal(170, thumbnail.Height);
@@ -337,7 +344,7 @@ namespace SixLabors.ImageSharp.Tests
                 image.Metadata.ExifProfile = expectedProfile;
 
                 // Act
-                Image<Rgba32> reloadedImage = WriteAndRead(image, TestImageWriteFormat.Jpeg);
+                using Image<Rgba32> reloadedImage = WriteAndRead(image, TestImageWriteFormat.Jpeg);
 
                 // Assert
                 ExifProfile actualProfile = reloadedImage.Metadata.ExifProfile;
@@ -361,7 +368,7 @@ namespace SixLabors.ImageSharp.Tests
         {
             // This image contains an 802 byte EXIF profile
             // It has a tag with an index offset of 18,481,152 bytes (overrunning the data)
-            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Progressive.Bad.ExifUndefType).CreateRgba32Image();
+            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Progressive.Bad.ExifUndefType).CreateRgba32Image();
             Assert.NotNull(image);
 
             ExifProfile profile = image.Metadata.ExifProfile;
@@ -381,7 +388,7 @@ namespace SixLabors.ImageSharp.Tests
         public void TestArrayValueWithUnspecifiedSize()
         {
             // This images contains array in the exif profile that has zero components.
-            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Issues.InvalidCast520).CreateRgba32Image();
+            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Issues.InvalidCast520).CreateRgba32Image();
 
             ExifProfile profile = image.Metadata.ExifProfile;
             Assert.NotNull(profile);
@@ -409,7 +416,7 @@ namespace SixLabors.ImageSharp.Tests
             image.Metadata.ExifProfile = CreateExifProfile();
 
             // Act
-            Image<Rgba32> reloadedImage = WriteAndRead(image, imageFormat);
+            using Image<Rgba32> reloadedImage = WriteAndRead(image, imageFormat);
 
             // Assert
             ExifProfile actual = reloadedImage.Metadata.ExifProfile;
@@ -460,7 +467,7 @@ namespace SixLabors.ImageSharp.Tests
 
         internal static ExifProfile GetExifProfile()
         {
-            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
+            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
 
             ExifProfile profile = image.Metadata.ExifProfile;
             Assert.NotNull(profile);

tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifReaderTests.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Exif
 {
     [Trait("Profile", "Exif")]
     public class ExifReaderTests

tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifTagDescriptionAttributeTests.cs

@@ -4,7 +4,7 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Exif
 {
     [Trait("Profile", "Exif")]
     public class ExifTagDescriptionAttributeTests

tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifValueTests.cs

@@ -5,12 +5,12 @@ using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Exif
 {
     [Trait("Profile", "Exif")]
     public class ExifValueTests
     {
-        private ExifProfile profile;
+        private readonly ExifProfile profile;
 
         public ExifValueTests()
         {

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderCurvesTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderCurvesTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataCurves.OneDimensionalCurveTestData), MemberType = typeof(IccTestDataCurves))]
         internal void ReadOneDimensionalCurve(byte[] data, IccOneDimensionalCurve expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccOneDimensionalCurve output = reader.ReadOneDimensionalCurve();
 
@@ -23,7 +24,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.ResponseCurveTestData), MemberType = typeof(IccTestDataCurves))]
         internal void ReadResponseCurve(byte[] data, IccResponseCurve expected, int channelCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccResponseCurve output = reader.ReadResponseCurve(channelCount);
 
@@ -34,7 +35,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.ParametricCurveTestData), MemberType = typeof(IccTestDataCurves))]
         internal void ReadParametricCurve(byte[] data, IccParametricCurve expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccParametricCurve output = reader.ReadParametricCurve();
 
@@ -45,7 +46,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.CurveSegmentTestData), MemberType = typeof(IccTestDataCurves))]
         internal void ReadCurveSegment(byte[] data, IccCurveSegment expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccCurveSegment output = reader.ReadCurveSegment();
 
@@ -56,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.FormulaCurveSegmentTestData), MemberType = typeof(IccTestDataCurves))]
         internal void ReadFormulaCurveElement(byte[] data, IccFormulaCurveElement expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccFormulaCurveElement output = reader.ReadFormulaCurveElement();
 
@@ -67,14 +68,14 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.SampledCurveSegmentTestData), MemberType = typeof(IccTestDataCurves))]
         internal void ReadSampledCurveElement(byte[] data, IccSampledCurveElement expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccSampledCurveElement output = reader.ReadSampledCurveElement();
 
             Assert.Equal(expected, output);
         }
 
-        private IccDataReader CreateReader(byte[] data)
+        private static IccDataReader CreateReader(byte[] data)
         {
             return new IccDataReader(data);
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderLutTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderLutTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataLut.ClutTestData), MemberType = typeof(IccTestDataLut))]
         internal void ReadClut(byte[] data, IccClut expected, int inChannelCount, int outChannelCount, bool isFloat)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccClut output = reader.ReadClut(inChannelCount, outChannelCount, isFloat);
 
@@ -23,7 +24,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void ReadClut8(byte[] data, IccClut expected, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccClut output = reader.ReadClut8(inChannelCount, outChannelCount, gridPointCount);
 
@@ -34,7 +35,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void ReadClut16(byte[] data, IccClut expected, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccClut output = reader.ReadClut16(inChannelCount, outChannelCount, gridPointCount);
 
@@ -45,7 +46,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.ClutF32TestData), MemberType = typeof(IccTestDataLut))]
         internal void ReadClutF32(byte[] data, IccClut expected, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccClut output = reader.ReadClutF32(inChannelCount, outChannelCount, gridPointCount);
 
@@ -56,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void ReadLut8(byte[] data, IccLut expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccLut output = reader.ReadLut8();
 
@@ -67,14 +68,14 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void ReadLut16(byte[] data, IccLut expected, int count)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccLut output = reader.ReadLut16(count);
 
             Assert.Equal(expected, output);
         }
 
-        private IccDataReader CreateReader(byte[] data)
+        private static IccDataReader CreateReader(byte[] data)
         {
             return new IccDataReader(data);
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMatrixTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderMatrixTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataMatrix.Matrix2D_FloatArrayTestData), MemberType = typeof(IccTestDataMatrix))]
         public void ReadMatrix2D(byte[] data, int xCount, int yCount, bool isSingle, float[,] expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             float[,] output = reader.ReadMatrix(xCount, yCount, isSingle);
 
@@ -23,14 +24,14 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMatrix.Matrix1D_ArrayTestData), MemberType = typeof(IccTestDataMatrix))]
         public void ReadMatrix1D(byte[] data, int yCount, bool isSingle, float[] expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             float[] output = reader.ReadMatrix(yCount, isSingle);
 
             Assert.Equal(expected, output);
         }
 
-        private IccDataReader CreateReader(byte[] data)
+        private static IccDataReader CreateReader(byte[] data)
         {
             return new IccDataReader(data);
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMultiProcessElementTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderMultiProcessElementTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataMultiProcessElements.MultiProcessElementTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void ReadMultiProcessElement(byte[] data, IccMultiProcessElement expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccMultiProcessElement output = reader.ReadMultiProcessElement();
 
@@ -23,7 +24,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMultiProcessElements.CurveSetTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void ReadCurveSetProcessElement(byte[] data, IccCurveSetProcessElement expected, int inChannelCount, int outChannelCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccCurveSetProcessElement output = reader.ReadCurveSetProcessElement(inChannelCount, outChannelCount);
 
@@ -34,7 +35,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMultiProcessElements.MatrixTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void ReadMatrixProcessElement(byte[] data, IccMatrixProcessElement expected, int inChannelCount, int outChannelCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccMatrixProcessElement output = reader.ReadMatrixProcessElement(inChannelCount, outChannelCount);
 
@@ -45,14 +46,14 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMultiProcessElements.ClutTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void ReadClutProcessElement(byte[] data, IccClutProcessElement expected, int inChannelCount, int outChannelCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccClutProcessElement output = reader.ReadClutProcessElement(inChannelCount, outChannelCount);
 
             Assert.Equal(expected, output);
         }
 
-        private IccDataReader CreateReader(byte[] data)
+        private static IccDataReader CreateReader(byte[] data)
         {
             return new IccDataReader(data);
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderNonPrimitivesTests.cs

@@ -6,15 +6,16 @@ using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderNonPrimitivesTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataNonPrimitives.DateTimeTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         public void ReadDateTime(byte[] data, DateTime expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             DateTime output = reader.ReadDateTime();
 
@@ -25,7 +26,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.VersionNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         public void ReadVersionNumber(byte[] data, IccVersion expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccVersion output = reader.ReadVersionNumber();
 
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.XyzNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         public void ReadXyzNumber(byte[] data, Vector3 expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             Vector3 output = reader.ReadXyzNumber();
 
@@ -47,7 +48,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ProfileIdTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void ReadProfileId(byte[] data, IccProfileId expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccProfileId output = reader.ReadProfileId();
 
@@ -58,7 +59,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.PositionNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void ReadPositionNumber(byte[] data, IccPositionNumber expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccPositionNumber output = reader.ReadPositionNumber();
 
@@ -69,7 +70,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ResponseNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void ReadResponseNumber(byte[] data, IccResponseNumber expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccResponseNumber output = reader.ReadResponseNumber();
 
@@ -80,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.NamedColorTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void ReadNamedColor(byte[] data, IccNamedColor expected, uint coordinateCount)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccNamedColor output = reader.ReadNamedColor(coordinateCount);
 
@@ -91,7 +92,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ProfileDescriptionReadTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void ReadProfileDescription(byte[] data, IccProfileDescription expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccProfileDescription output = reader.ReadProfileDescription();
 
@@ -102,7 +103,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ColorantTableEntryTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void ReadColorantTableEntry(byte[] data, IccColorantTableEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccColorantTableEntry output = reader.ReadColorantTableEntry();
 
@@ -113,14 +114,14 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ScreeningChannelTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void ReadScreeningChannel(byte[] data, IccScreeningChannel expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccScreeningChannel output = reader.ReadScreeningChannel();
 
             Assert.Equal(expected, output);
         }
 
-        private IccDataReader CreateReader(byte[] data)
+        private static IccDataReader CreateReader(byte[] data)
         {
             return new IccDataReader(data);
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderPrimitivesTests.cs

@@ -5,15 +5,16 @@ using System;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderPrimitivesTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataPrimitives.AsciiTestData), MemberType = typeof(IccTestDataPrimitives))]
         public void ReadAsciiString(byte[] textBytes, int length, string expected)
         {
-            IccDataReader reader = this.CreateReader(textBytes);
+            IccDataReader reader = CreateReader(textBytes);
 
             string output = reader.ReadAsciiString(length);
 
@@ -23,7 +24,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [Fact]
         public void ReadAsciiStringWithNegativeLengthThrowsArgumentException()
         {
-            IccDataReader reader = this.CreateReader(new byte[4]);
+            IccDataReader reader = CreateReader(new byte[4]);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => reader.ReadAsciiString(-1));
         }
@@ -31,7 +32,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [Fact]
         public void ReadUnicodeStringWithNegativeLengthThrowsArgumentException()
         {
-            IccDataReader reader = this.CreateReader(new byte[4]);
+            IccDataReader reader = CreateReader(new byte[4]);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => reader.ReadUnicodeString(-1));
         }
@@ -40,7 +41,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.Fix16TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void ReadFix16(byte[] data, float expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             float output = reader.ReadFix16();
 
@@ -51,7 +52,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.UFix16TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void ReadUFix16(byte[] data, float expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             float output = reader.ReadUFix16();
 
@@ -62,7 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.U1Fix15TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void ReadU1Fix15(byte[] data, float expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             float output = reader.ReadU1Fix15();
 
@@ -73,14 +74,14 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.UFix8TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void ReadUFix8(byte[] data, float expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             float output = reader.ReadUFix8();
 
             Assert.Equal(expected, output);
         }
 
-        private IccDataReader CreateReader(byte[] data)
+        private static IccDataReader CreateReader(byte[] data)
         {
             return new IccDataReader(data);
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTagDataEntryTests.cs

@@ -4,8 +4,9 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderTagDataEntryTests
     {
         [Theory]
@@ -14,7 +15,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadUnknownTagDataEntry(byte[] data, IccUnknownTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccUnknownTagDataEntry output = reader.ReadUnknownTagDataEntry(size);
 
@@ -27,7 +28,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadChromaticityTagDataEntry(byte[] data, IccChromaticityTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccChromaticityTagDataEntry output = reader.ReadChromaticityTagDataEntry();
 
@@ -40,7 +41,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadColorantOrderTagDataEntry(byte[] data, IccColorantOrderTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccColorantOrderTagDataEntry output = reader.ReadColorantOrderTagDataEntry();
 
@@ -53,7 +54,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadColorantTableTagDataEntry(byte[] data, IccColorantTableTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccColorantTableTagDataEntry output = reader.ReadColorantTableTagDataEntry();
 
@@ -66,7 +67,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadCurveTagDataEntry(byte[] data, IccCurveTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccCurveTagDataEntry output = reader.ReadCurveTagDataEntry();
 
@@ -79,7 +80,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadDataTagDataEntry(byte[] data, IccDataTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccDataTagDataEntry output = reader.ReadDataTagDataEntry(size);
 
@@ -92,7 +93,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadDateTimeTagDataEntry(byte[] data, IccDateTimeTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccDateTimeTagDataEntry output = reader.ReadDateTimeTagDataEntry();
 
@@ -105,7 +106,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadLut16TagDataEntry(byte[] data, IccLut16TagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccLut16TagDataEntry output = reader.ReadLut16TagDataEntry();
 
@@ -118,7 +119,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadLut8TagDataEntry(byte[] data, IccLut8TagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccLut8TagDataEntry output = reader.ReadLut8TagDataEntry();
 
@@ -131,7 +132,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadLutAToBTagDataEntry(byte[] data, IccLutAToBTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccLutAToBTagDataEntry output = reader.ReadLutAtoBTagDataEntry();
 
@@ -144,7 +145,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadLutBToATagDataEntry(byte[] data, IccLutBToATagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccLutBToATagDataEntry output = reader.ReadLutBtoATagDataEntry();
 
@@ -157,7 +158,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadMeasurementTagDataEntry(byte[] data, IccMeasurementTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccMeasurementTagDataEntry output = reader.ReadMeasurementTagDataEntry();
 
@@ -170,7 +171,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadMultiLocalizedUnicodeTagDataEntry(byte[] data, IccMultiLocalizedUnicodeTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccMultiLocalizedUnicodeTagDataEntry output = reader.ReadMultiLocalizedUnicodeTagDataEntry();
 
@@ -183,7 +184,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadMultiProcessElementsTagDataEntry(byte[] data, IccMultiProcessElementsTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccMultiProcessElementsTagDataEntry output = reader.ReadMultiProcessElementsTagDataEntry();
 
@@ -196,7 +197,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadNamedColor2TagDataEntry(byte[] data, IccNamedColor2TagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccNamedColor2TagDataEntry output = reader.ReadNamedColor2TagDataEntry();
 
@@ -209,7 +210,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadParametricCurveTagDataEntry(byte[] data, IccParametricCurveTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccParametricCurveTagDataEntry output = reader.ReadParametricCurveTagDataEntry();
 
@@ -222,7 +223,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadProfileSequenceDescTagDataEntry(byte[] data, IccProfileSequenceDescTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccProfileSequenceDescTagDataEntry output = reader.ReadProfileSequenceDescTagDataEntry();
 
@@ -237,7 +238,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             byte[] data,
             IccProfileSequenceIdentifierTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccProfileSequenceIdentifierTagDataEntry output = reader.ReadProfileSequenceIdentifierTagDataEntry();
 
@@ -250,7 +251,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadResponseCurveSet16TagDataEntry(byte[] data, IccResponseCurveSet16TagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccResponseCurveSet16TagDataEntry output = reader.ReadResponseCurveSet16TagDataEntry();
 
@@ -263,7 +264,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadFix16ArrayTagDataEntry(byte[] data, IccFix16ArrayTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccFix16ArrayTagDataEntry output = reader.ReadFix16ArrayTagDataEntry(size);
 
@@ -276,7 +277,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadSignatureTagDataEntry(byte[] data, IccSignatureTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccSignatureTagDataEntry output = reader.ReadSignatureTagDataEntry();
 
@@ -289,7 +290,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadTextTagDataEntry(byte[] data, IccTextTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccTextTagDataEntry output = reader.ReadTextTagDataEntry(size);
 
@@ -302,7 +303,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadUFix16ArrayTagDataEntry(byte[] data, IccUFix16ArrayTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccUFix16ArrayTagDataEntry output = reader.ReadUFix16ArrayTagDataEntry(size);
 
@@ -315,7 +316,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadUInt16ArrayTagDataEntry(byte[] data, IccUInt16ArrayTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccUInt16ArrayTagDataEntry output = reader.ReadUInt16ArrayTagDataEntry(size);
 
@@ -328,7 +329,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadUInt32ArrayTagDataEntry(byte[] data, IccUInt32ArrayTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccUInt32ArrayTagDataEntry output = reader.ReadUInt32ArrayTagDataEntry(size);
 
@@ -341,7 +342,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadUInt64ArrayTagDataEntry(byte[] data, IccUInt64ArrayTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccUInt64ArrayTagDataEntry output = reader.ReadUInt64ArrayTagDataEntry(size);
 
@@ -354,7 +355,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadUInt8ArrayTagDataEntry(byte[] data, IccUInt8ArrayTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccUInt8ArrayTagDataEntry output = reader.ReadUInt8ArrayTagDataEntry(size);
 
@@ -367,7 +368,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadViewingConditionsTagDataEntry(byte[] data, IccViewingConditionsTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccViewingConditionsTagDataEntry output = reader.ReadViewingConditionsTagDataEntry();
 
@@ -380,7 +381,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadXyzTagDataEntry(byte[] data, IccXyzTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccXyzTagDataEntry output = reader.ReadXyzTagDataEntry(size);
 
@@ -393,7 +394,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadTextDescriptionTagDataEntry(byte[] data, IccTextDescriptionTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccTextDescriptionTagDataEntry output = reader.ReadTextDescriptionTagDataEntry();
 
@@ -406,7 +407,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadCrdInfoTagDataEntry(byte[] data, IccCrdInfoTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccCrdInfoTagDataEntry output = reader.ReadCrdInfoTagDataEntry();
 
@@ -419,7 +420,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadScreeningTagDataEntry(byte[] data, IccScreeningTagDataEntry expected)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccScreeningTagDataEntry output = reader.ReadScreeningTagDataEntry();
 
@@ -432,14 +433,14 @@ namespace SixLabors.ImageSharp.Tests.Icc
             MemberType = typeof(IccTestDataTagDataEntry))]
         internal void ReadUcrBgTagDataEntry(byte[] data, IccUcrBgTagDataEntry expected, uint size)
         {
-            IccDataReader reader = this.CreateReader(data);
+            IccDataReader reader = CreateReader(data);
 
             IccUcrBgTagDataEntry output = reader.ReadUcrBgTagDataEntry(size);
 
             Assert.Equal(expected, output);
         }
 
-        private IccDataReader CreateReader(byte[] data)
+        private static IccDataReader CreateReader(byte[] data)
         {
             return new IccDataReader(data);
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTests.cs

@@ -1,12 +1,13 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader
 {
+    [Trait("Profile", "Icc")]
     public class IccDataReaderTests
     {
         [Fact]

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterCurvesTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterCurvesTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataCurves.OneDimensionalCurveTestData), MemberType = typeof(IccTestDataCurves))]
         internal void WriteOneDimensionalCurve(byte[] expected, IccOneDimensionalCurve data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteOneDimensionalCurve(data);
             byte[] output = writer.GetData();
@@ -24,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.ResponseCurveTestData), MemberType = typeof(IccTestDataCurves))]
         internal void WriteResponseCurve(byte[] expected, IccResponseCurve data, int channelCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteResponseCurve(data);
             byte[] output = writer.GetData();
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.ParametricCurveTestData), MemberType = typeof(IccTestDataCurves))]
         internal void WriteParametricCurve(byte[] expected, IccParametricCurve data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteParametricCurve(data);
             byte[] output = writer.GetData();
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.CurveSegmentTestData), MemberType = typeof(IccTestDataCurves))]
         internal void WriteCurveSegment(byte[] expected, IccCurveSegment data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteCurveSegment(data);
             byte[] output = writer.GetData();
@@ -60,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.FormulaCurveSegmentTestData), MemberType = typeof(IccTestDataCurves))]
         internal void WriteFormulaCurveElement(byte[] expected, IccFormulaCurveElement data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteFormulaCurveElement(data);
             byte[] output = writer.GetData();
@@ -72,7 +73,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataCurves.SampledCurveSegmentTestData), MemberType = typeof(IccTestDataCurves))]
         internal void WriteSampledCurveElement(byte[] expected, IccSampledCurveElement data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteSampledCurveElement(data);
             byte[] output = writer.GetData();
@@ -80,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterLutTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataLut.ClutTestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClutAll(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, bool isFloat)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut(data);
             byte[] output = writer.GetData();
@@ -24,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClut8(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut8(data);
             byte[] output = writer.GetData();
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClut16(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut16(data);
             byte[] output = writer.GetData();
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.ClutF32TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClutF32(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClutF32(data);
             byte[] output = writer.GetData();
@@ -60,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteLut8(byte[] expected, IccLut data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut8(data);
             byte[] output = writer.GetData();
@@ -72,7 +73,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteLut16(byte[] expected, IccLut data, int count)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut16(data);
             byte[] output = writer.GetData();
@@ -80,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests1.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterLutTests1
     {
         [Theory]
         [MemberData(nameof(IccTestDataLut.ClutTestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClutAll(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, bool isFloat)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut(data);
             byte[] output = writer.GetData();
@@ -24,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClut8(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut8(data);
             byte[] output = writer.GetData();
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClut16(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut16(data);
             byte[] output = writer.GetData();
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.ClutF32TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClutF32(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClutF32(data);
             byte[] output = writer.GetData();
@@ -60,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteLut8(byte[] expected, IccLut data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut8(data);
             byte[] output = writer.GetData();
@@ -72,7 +73,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteLut16(byte[] expected, IccLut data, int count)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut16(data);
             byte[] output = writer.GetData();
@@ -80,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests2.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterLutTests2
     {
         [Theory]
         [MemberData(nameof(IccTestDataLut.ClutTestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClutAll(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, bool isFloat)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut(data);
             byte[] output = writer.GetData();
@@ -24,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClut8(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut8(data);
             byte[] output = writer.GetData();
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Clut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClut16(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClut16(data);
             byte[] output = writer.GetData();
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.ClutF32TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteClutF32(byte[] expected, IccClut data, int inChannelCount, int outChannelCount, byte[] gridPointCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClutF32(data);
             byte[] output = writer.GetData();
@@ -60,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut8TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteLut8(byte[] expected, IccLut data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut8(data);
             byte[] output = writer.GetData();
@@ -72,7 +73,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataLut.Lut16TestData), MemberType = typeof(IccTestDataLut))]
         internal void WriteLut16(byte[] expected, IccLut data, int count)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut16(data);
             byte[] output = writer.GetData();
@@ -80,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMatrixTests.cs

@@ -6,17 +6,16 @@ using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
-    using SixLabors.ImageSharp;
-
+    [Trait("Profile", "Icc")]
     public class IccDataWriterMatrixTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataMatrix.Matrix2D_FloatArrayTestData), MemberType = typeof(IccTestDataMatrix))]
         public void WriteMatrix2D_Array(byte[] expected, int xCount, int yCount, bool isSingle, float[,] data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMatrix(data, isSingle);
             byte[] output = writer.GetData();
@@ -28,7 +27,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMatrix.Matrix2D_Matrix4x4TestData), MemberType = typeof(IccTestDataMatrix))]
         public void WriteMatrix2D_Matrix4x4(byte[] expected, int xCount, int yCount, bool isSingle, Matrix4x4 data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMatrix(data, isSingle);
             byte[] output = writer.GetData();
@@ -40,7 +39,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMatrix.Matrix2D_DenseMatrixTestData), MemberType = typeof(IccTestDataMatrix))]
         internal void WriteMatrix2D_DenseMatrix(byte[] expected, int xCount, int yCount, bool isSingle, in DenseMatrix<float> data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMatrix(data, isSingle);
             byte[] output = writer.GetData();
@@ -52,7 +51,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMatrix.Matrix1D_ArrayTestData), MemberType = typeof(IccTestDataMatrix))]
         public void WriteMatrix1D_Array(byte[] expected, int yCount, bool isSingle, float[] data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMatrix(data, isSingle);
             byte[] output = writer.GetData();
@@ -64,7 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMatrix.Matrix1D_Vector3TestData), MemberType = typeof(IccTestDataMatrix))]
         public void WriteMatrix1D_Vector3(byte[] expected, int yCount, bool isSingle, Vector3 data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMatrix(data, isSingle);
             byte[] output = writer.GetData();
@@ -72,7 +71,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMultiProcessElementTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterMultiProcessElementTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataMultiProcessElements.MultiProcessElementTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void WriteMultiProcessElement(byte[] expected, IccMultiProcessElement data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMultiProcessElement(data);
             byte[] output = writer.GetData();
@@ -24,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMultiProcessElements.CurveSetTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void WriteCurveSetProcessElement(byte[] expected, IccCurveSetProcessElement data, int inChannelCount, int outChannelCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteCurveSetProcessElement(data);
             byte[] output = writer.GetData();
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMultiProcessElements.MatrixTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void WriteMatrixProcessElement(byte[] expected, IccMatrixProcessElement data, int inChannelCount, int outChannelCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMatrixProcessElement(data);
             byte[] output = writer.GetData();
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataMultiProcessElements.ClutTestData), MemberType = typeof(IccTestDataMultiProcessElements))]
         internal void WriteClutProcessElement(byte[] expected, IccClutProcessElement data, int inChannelCount, int outChannelCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteClutProcessElement(data);
             byte[] output = writer.GetData();
@@ -56,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterNonPrimitivesTests.cs

@@ -6,15 +6,16 @@ using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterNonPrimitivesTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataNonPrimitives.DateTimeTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         public void WriteDateTime(byte[] expected, DateTime data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteDateTime(data);
             byte[] output = writer.GetData();
@@ -26,7 +27,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.VersionNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         public void WriteVersionNumber(byte[] expected, IccVersion data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteVersionNumber(data);
             byte[] output = writer.GetData();
@@ -38,7 +39,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.XyzNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         public void WriteXyzNumber(byte[] expected, Vector3 data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteXyzNumber(data);
             byte[] output = writer.GetData();
@@ -50,7 +51,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ProfileIdTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void WriteProfileId(byte[] expected, IccProfileId data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteProfileId(data);
             byte[] output = writer.GetData();
@@ -62,7 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.PositionNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void WritePositionNumber(byte[] expected, IccPositionNumber data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WritePositionNumber(data);
             byte[] output = writer.GetData();
@@ -74,7 +75,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ResponseNumberTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void WriteResponseNumber(byte[] expected, IccResponseNumber data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteResponseNumber(data);
             byte[] output = writer.GetData();
@@ -86,7 +87,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.NamedColorTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void WriteNamedColor(byte[] expected, IccNamedColor data, uint coordinateCount)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteNamedColor(data);
             byte[] output = writer.GetData();
@@ -98,7 +99,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ProfileDescriptionWriteTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void WriteProfileDescription(byte[] expected, IccProfileDescription data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteProfileDescription(data);
             byte[] output = writer.GetData();
@@ -110,7 +111,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataNonPrimitives.ScreeningChannelTestData), MemberType = typeof(IccTestDataNonPrimitives))]
         internal void WriteScreeningChannel(byte[] expected, IccScreeningChannel data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteScreeningChannel(data);
             byte[] output = writer.GetData();
@@ -118,7 +119,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterPrimitivesTests.cs

@@ -5,15 +5,16 @@ using System;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterPrimitivesTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataPrimitives.AsciiWriteTestData), MemberType = typeof(IccTestDataPrimitives))]
         public void WriteAsciiString(byte[] expected, string data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteAsciiString(data);
             byte[] output = writer.GetData();
@@ -25,7 +26,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.AsciiPaddingTestData), MemberType = typeof(IccTestDataPrimitives))]
         public void WriteAsciiStringPadded(byte[] expected, int length, string data, bool ensureNullTerminator)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteAsciiString(data, length, ensureNullTerminator);
             byte[] output = writer.GetData();
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [Fact]
         public void WriteAsciiStringWithNullWritesEmpty()
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             int count = writer.WriteAsciiString(null);
             byte[] output = writer.GetData();
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [Fact]
         public void WriteAsciiStringWithNegativeLengthThrowsArgumentException()
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteAsciiString("abcd", -1, false));
         }
@@ -56,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [Fact]
         public void WriteUnicodeStringWithNullWritesEmpty()
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             int count = writer.WriteUnicodeString(null);
             byte[] output = writer.GetData();
@@ -69,7 +70,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.Fix16TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void WriteFix16(byte[] expected, float data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteFix16(data);
             byte[] output = writer.GetData();
@@ -81,7 +82,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.UFix16TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void WriteUFix16(byte[] expected, float data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUFix16(data);
             byte[] output = writer.GetData();
@@ -93,7 +94,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.U1Fix15TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void WriteU1Fix15(byte[] expected, float data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteU1Fix15(data);
             byte[] output = writer.GetData();
@@ -105,7 +106,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataPrimitives.UFix8TestData), MemberType = typeof(IccTestDataPrimitives))]
         public void WriteUFix8(byte[] expected, float data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUFix8(data);
             byte[] output = writer.GetData();
@@ -113,7 +114,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTagDataEntryTests.cs

@@ -4,15 +4,16 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterTagDataEntryTests
     {
         [Theory]
         [MemberData(nameof(IccTestDataTagDataEntry.UnknownTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteUnknownTagDataEntry(byte[] expected, IccUnknownTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUnknownTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -24,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ChromaticityTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteChromaticityTagDataEntry(byte[] expected, IccChromaticityTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteChromaticityTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -36,7 +37,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ColorantOrderTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteColorantOrderTagDataEntry(byte[] expected, IccColorantOrderTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteColorantOrderTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ColorantTableTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteColorantTableTagDataEntry(byte[] expected, IccColorantTableTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteColorantTableTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -60,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.CurveTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteCurveTagDataEntry(byte[] expected, IccCurveTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteCurveTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -72,7 +73,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.DataTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteDataTagDataEntry(byte[] expected, IccDataTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteDataTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -84,7 +85,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.DateTimeTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteDateTimeTagDataEntry(byte[] expected, IccDateTimeTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteDateTimeTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -96,7 +97,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.Lut16TagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteLut16TagDataEntry(byte[] expected, IccLut16TagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut16TagDataEntry(data);
             byte[] output = writer.GetData();
@@ -108,7 +109,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.Lut8TagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteLut8TagDataEntry(byte[] expected, IccLut8TagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLut8TagDataEntry(data);
             byte[] output = writer.GetData();
@@ -120,7 +121,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.LutAToBTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteLutAToBTagDataEntry(byte[] expected, IccLutAToBTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLutAtoBTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -132,7 +133,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.LutBToATagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteLutBToATagDataEntry(byte[] expected, IccLutBToATagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteLutBtoATagDataEntry(data);
             byte[] output = writer.GetData();
@@ -144,7 +145,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.MeasurementTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteMeasurementTagDataEntry(byte[] expected, IccMeasurementTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMeasurementTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -156,7 +157,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.MultiLocalizedUnicodeTagDataEntryTestData_Write), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteMultiLocalizedUnicodeTagDataEntry(byte[] expected, IccMultiLocalizedUnicodeTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMultiLocalizedUnicodeTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -168,7 +169,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.MultiProcessElementsTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteMultiProcessElementsTagDataEntry(byte[] expected, IccMultiProcessElementsTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteMultiProcessElementsTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -180,7 +181,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.NamedColor2TagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteNamedColor2TagDataEntry(byte[] expected, IccNamedColor2TagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteNamedColor2TagDataEntry(data);
             byte[] output = writer.GetData();
@@ -192,7 +193,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ParametricCurveTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteParametricCurveTagDataEntry(byte[] expected, IccParametricCurveTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteParametricCurveTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -204,7 +205,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ProfileSequenceDescTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteProfileSequenceDescTagDataEntry(byte[] expected, IccProfileSequenceDescTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteProfileSequenceDescTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -216,7 +217,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ProfileSequenceIdentifierTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteProfileSequenceIdentifierTagDataEntry(byte[] expected, IccProfileSequenceIdentifierTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteProfileSequenceIdentifierTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -228,7 +229,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ResponseCurveSet16TagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteResponseCurveSet16TagDataEntry(byte[] expected, IccResponseCurveSet16TagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteResponseCurveSet16TagDataEntry(data);
             byte[] output = writer.GetData();
@@ -240,7 +241,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.Fix16ArrayTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteFix16ArrayTagDataEntry(byte[] expected, IccFix16ArrayTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteFix16ArrayTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -252,7 +253,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.SignatureTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteSignatureTagDataEntry(byte[] expected, IccSignatureTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteSignatureTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -264,7 +265,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.TextTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteTextTagDataEntry(byte[] expected, IccTextTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteTextTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -276,7 +277,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.UFix16ArrayTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteUFix16ArrayTagDataEntry(byte[] expected, IccUFix16ArrayTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUFix16ArrayTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -288,7 +289,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.UInt16ArrayTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteUInt16ArrayTagDataEntry(byte[] expected, IccUInt16ArrayTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUInt16ArrayTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -300,7 +301,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.UInt32ArrayTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteUInt32ArrayTagDataEntry(byte[] expected, IccUInt32ArrayTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUInt32ArrayTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -312,7 +313,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.UInt64ArrayTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteUInt64ArrayTagDataEntry(byte[] expected, IccUInt64ArrayTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUInt64ArrayTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -324,7 +325,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.UInt8ArrayTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteUInt8ArrayTagDataEntry(byte[] expected, IccUInt8ArrayTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUInt8ArrayTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -336,7 +337,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ViewingConditionsTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteViewingConditionsTagDataEntry(byte[] expected, IccViewingConditionsTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteViewingConditionsTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -348,7 +349,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.XYZTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteXyzTagDataEntry(byte[] expected, IccXyzTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteXyzTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -360,7 +361,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.TextDescriptionTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteTextDescriptionTagDataEntry(byte[] expected, IccTextDescriptionTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteTextDescriptionTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -372,7 +373,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.CrdInfoTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteCrdInfoTagDataEntry(byte[] expected, IccCrdInfoTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteCrdInfoTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -384,7 +385,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.ScreeningTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteScreeningTagDataEntry(byte[] expected, IccScreeningTagDataEntry data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteScreeningTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -396,7 +397,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataTagDataEntry.UcrBgTagDataEntryTestData), MemberType = typeof(IccTestDataTagDataEntry))]
         internal void WriteUcrBgTagDataEntry(byte[] expected, IccUcrBgTagDataEntry data, uint size)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteUcrBgTagDataEntry(data);
             byte[] output = writer.GetData();
@@ -404,7 +405,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTests.cs

@@ -4,14 +4,15 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter
 {
+    [Trait("Profile", "Icc")]
     public class IccDataWriterTests
     {
         [Fact]
         public void WriteEmpty()
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteEmpty(4);
             byte[] output = writer.GetData();
@@ -24,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [InlineData(4, 4)]
         public void WritePadding(int writePosition, int expectedLength)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteEmpty(writePosition);
             writer.WritePadding();
@@ -37,7 +38,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataArray.UInt8TestData), MemberType = typeof(IccTestDataArray))]
         public void WriteArrayUInt8(byte[] data, byte[] expected)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteArray(data);
             byte[] output = writer.GetData();
@@ -49,7 +50,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataArray.UInt16TestData), MemberType = typeof(IccTestDataArray))]
         public void WriteArrayUInt16(byte[] expected, ushort[] data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteArray(data);
             byte[] output = writer.GetData();
@@ -61,7 +62,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataArray.Int16TestData), MemberType = typeof(IccTestDataArray))]
         public void WriteArrayInt16(byte[] expected, short[] data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteArray(data);
             byte[] output = writer.GetData();
@@ -73,7 +74,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataArray.UInt32TestData), MemberType = typeof(IccTestDataArray))]
         public void WriteArrayUInt32(byte[] expected, uint[] data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteArray(data);
             byte[] output = writer.GetData();
@@ -85,7 +86,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataArray.Int32TestData), MemberType = typeof(IccTestDataArray))]
         public void WriteArrayInt32(byte[] expected, int[] data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteArray(data);
             byte[] output = writer.GetData();
@@ -97,7 +98,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
         [MemberData(nameof(IccTestDataArray.UInt64TestData), MemberType = typeof(IccTestDataArray))]
         public void WriteArrayUInt64(byte[] expected, ulong[] data)
         {
-            IccDataWriter writer = this.CreateWriter();
+            using IccDataWriter writer = CreateWriter();
 
             writer.WriteArray(data);
             byte[] output = writer.GetData();
@@ -105,7 +106,7 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(expected, output);
         }
 
-        private IccDataWriter CreateWriter()
+        private static IccDataWriter CreateWriter()
         {
             return new IccDataWriter();
         }

tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccProfileTests.cs

@@ -5,8 +5,9 @@ using System;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Icc
 {
+    [Trait("Profile", "Icc")]
     public class IccProfileTests
     {
         [Theory]

tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccReaderTests.cs

@@ -4,8 +4,9 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Icc
 {
+    [Trait("Profile", "Icc")]
     public class IccReaderTests
     {
         [Fact]

tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccWriterTests.cs

@@ -4,8 +4,9 @@
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Icc
 {
+    [Trait("Profile", "Icc")]
     public class IccWriterTests
     {
         [Fact]

tests/ImageSharp.Tests/Metadata/Profiles/ICC/Various/IccProfileIdTests.cs

@@ -1,11 +1,12 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Icc
+namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.Various
 {
+    [Trait("Profile", "Icc")]
     public class IccProfileIdTests
     {
         [Fact]
@@ -29,4 +30,4 @@ namespace SixLabors.ImageSharp.Tests.Icc
             Assert.Equal(4u, id.Part4);
         }
     }
-}
+}

tests/ImageSharp.Tests/Metadata/Profiles/IPTC/IptcProfileTests.cs

@@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.IPTC
             // arrange
             var profile = new IptcProfile();
             var value = new string('s', tag.MaxLength() + 1);
-            var expectedLength = tag.MaxLength();
+            int expectedLength = tag.MaxLength();
 
             // act
             profile.SetValue(tag, value);
@@ -51,7 +51,7 @@ namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.IPTC
             // arrange
             var profile = new IptcProfile();
             var value = new string('s', tag.MaxLength() + 1);
-            var expectedLength = value.Length;
+            int expectedLength = value.Length;
 
             // act
             profile.SetValue(tag, value, false);
@@ -228,7 +228,7 @@ namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.IPTC
             image.Metadata.IptcProfile.SetValue(IptcTag.Caption, expectedCaption);
 
             // act
-            Image<Rgba32> reloadedImage = WriteAndReadJpeg(image);
+            using Image<Rgba32> reloadedImage = WriteAndReadJpeg(image);
 
             // assert
             IptcProfile actual = reloadedImage.Metadata.IptcProfile;

tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs

@@ -110,7 +110,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations
         [Fact]
         public void PixelTypeInfoHasCorrectBitsPerPixel()
         {
-            var bits = this.Operations.GetPixelTypeInfo().BitsPerPixel;
+            int bits = this.Operations.GetPixelTypeInfo().BitsPerPixel;
             Assert.Equal(Unsafe.SizeOf<TPixel>() * 8, bits);
         }
 

tests/ImageSharp.Tests/Processing/BaseImageOperationsExtensionTest.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System.ComponentModel.DataAnnotations;
+using System;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
@@ -10,7 +10,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing
 {
-    public abstract class BaseImageOperationsExtensionTest
+    public abstract class BaseImageOperationsExtensionTest : IDisposable
     {
         protected readonly IImageProcessingContext operations;
         private readonly FakeImageOperationsProvider.FakeImageOperations<Rgba32> internalOperations;
@@ -59,5 +59,7 @@ namespace SixLabors.ImageSharp.Tests.Processing
 
             return Assert.IsType<T>(operation.GenericProcessor);
         }
+
+        public void Dispose() => this.source?.Dispose();
     }
 }

tests/ImageSharp.Tests/Processing/Binarization/AdaptiveThresholdTests.cs

@@ -9,13 +9,14 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Binarization
 {
+    [Trait("Category", "Processors")]
     public class AdaptiveThresholdTests : BaseImageOperationsExtensionTest
     {
         [Fact]
         public void AdaptiveThreshold_UsesDefaults_Works()
         {
             // arrange
-            var expectedThresholdLimit = .85f;
+            float expectedThresholdLimit = .85f;
             Color expectedUpper = Color.White;
             Color expectedLower = Color.Black;
 
@@ -33,7 +34,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         public void AdaptiveThreshold_SettingThresholdLimit_Works()
         {
             // arrange
-            var expectedThresholdLimit = .65f;
+            float expectedThresholdLimit = .65f;
 
             // act
             this.operations.AdaptiveThreshold(expectedThresholdLimit);
@@ -65,7 +66,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         public void AdaptiveThreshold_SettingUpperLowerWithThresholdLimit_Works()
         {
             // arrange
-            var expectedThresholdLimit = .77f;
+            float expectedThresholdLimit = .77f;
             Color expectedUpper = Color.HotPink;
             Color expectedLower = Color.Yellow;
 
@@ -83,7 +84,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         public void AdaptiveThreshold_SettingUpperLowerWithThresholdLimit_WithRectangle_Works()
         {
             // arrange
-            var expectedThresholdLimit = .77f;
+            float expectedThresholdLimit = .77f;
             Color expectedUpper = Color.HotPink;
             Color expectedLower = Color.Yellow;
 

tests/ImageSharp.Tests/Processing/Binarization/BinaryThresholdTest.cs

@@ -8,6 +8,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Binarization
 {
+    [Trait("Category", "Processors")]
     public class BinaryThresholdTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Binarization/OrderedDitherFactoryTests.cs

@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Binarization
 {
+    [Trait("Category", "Processors")]
     public class OrderedDitherFactoryTests
     {
 #pragma warning disable SA1025 // Code should not contain multiple whitespace in a row

tests/ImageSharp.Tests/Processing/Convolution/BoxBlurTest.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Processing;
@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Convolution
 {
+    [Trait("Category", "Processors")]
     public class BoxBlurTest : BaseImageOperationsExtensionTest
     {
         [Fact]
@@ -36,4 +37,4 @@ namespace SixLabors.ImageSharp.Tests.Processing.Convolution
             Assert.Equal(5, processor.Radius);
         }
     }
-}
+}

tests/ImageSharp.Tests/Processing/Convolution/DetectEdgesTest.cs

@@ -8,6 +8,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Convolution
 {
+    [Trait("Category", "Processors")]
     [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "OK. Used for TheoryData compatibility.")]
     public class DetectEdgesTest : BaseImageOperationsExtensionTest
     {

tests/ImageSharp.Tests/Processing/Convolution/GaussianBlurTest.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Processing;
@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Convolution
 {
+    [Trait("Category", "Processors")]
     public class GaussianBlurTest : BaseImageOperationsExtensionTest
     {
         [Fact]
@@ -36,4 +37,4 @@ namespace SixLabors.ImageSharp.Tests.Processing.Convolution
             Assert.Equal(.6f, processor.Sigma);
         }
     }
-}
+}

tests/ImageSharp.Tests/Processing/Convolution/GaussianSharpenTest.cs

@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Convolution
 {
+    [Trait("Category", "Processors")]
     public class GaussianSharpenTest : BaseImageOperationsExtensionTest
     {
         [Fact]
@@ -36,4 +37,4 @@ namespace SixLabors.ImageSharp.Tests.Processing.Convolution
             Assert.Equal(.6f, processor.Sigma);
         }
     }
-}
+}

tests/ImageSharp.Tests/Processing/Convolution/Processors/LaplacianKernelFactoryTests.cs

@@ -5,7 +5,7 @@ using System;
 using SixLabors.ImageSharp.Processing.Processors.Convolution;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Processing.Processors.Convolution
+namespace SixLabors.ImageSharp.Tests.Processing.Convolution.Processors
 {
     public class LaplacianKernelFactoryTests
     {

tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs

@@ -6,8 +6,9 @@ using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Dithering;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Processing.Binarization
+namespace SixLabors.ImageSharp.Tests.Processing.Dithering
 {
+    [Trait("Category", "Processors")]
     public class DitherTest : BaseImageOperationsExtensionTest
     {
         private class Assert : Xunit.Assert

tests/ImageSharp.Tests/Processing/Effects/BackgroundColorTest.cs

@@ -3,11 +3,11 @@
 
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Overlays;
-using SixLabors.ImageSharp.Tests.TestUtilities;
 using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Effects
 {
+    [Trait("Category", "Processors")]
     public class BackgroundColorTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Effects/OilPaintTest.cs

@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Effects
 {
+    [Trait("Category", "Processors")]
     public class OilPaintTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Effects/PixelateTest.cs

@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Effects
 {
+    [Trait("Category", "Processors")]
     public class PixelateTest : BaseImageOperationsExtensionTest
     {
         [Fact]
@@ -36,4 +37,4 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
             Assert.Equal(23, processor.Size);
         }
     }
-}
+}

tests/ImageSharp.Tests/Processing/Filters/BlackWhiteTest.cs

@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class BlackWhiteTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Filters/BrightnessTest.cs

@@ -6,8 +6,9 @@ using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Filters;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Processing.Effects
+namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class BrightnessTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Filters/ColorBlindnessTest.cs

@@ -12,6 +12,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class ColorBlindnessTest : BaseImageOperationsExtensionTest
     {
         public static IEnumerable<object[]> TheoryData = new[]

tests/ImageSharp.Tests/Processing/Filters/ContrastTest.cs

@@ -1,13 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Filters;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Processing.Effects
+namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
-    using SixLabors.ImageSharp.Processing;
-    using SixLabors.ImageSharp.Processing.Processors.Filters;
-
+    [Trait("Category", "Processors")]
     public class ContrastTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Filters/FilterTest.cs

@@ -1,13 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Filters;
 using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
-    using SixLabors.ImageSharp.Processing;
-    using SixLabors.ImageSharp.Processing.Processors.Filters;
-
+    [Trait("Category", "Processors")]
     public class FilterTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Filters/GrayscaleTest.cs

@@ -12,6 +12,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class GrayscaleTest : BaseImageOperationsExtensionTest
     {
         public static IEnumerable<object[]> ModeTheoryData = new[]

tests/ImageSharp.Tests/Processing/Filters/HueTest.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Processing;
@@ -8,6 +8,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class HueTest : BaseImageOperationsExtensionTest
     {
         [Fact]
@@ -28,4 +29,4 @@ namespace SixLabors.ImageSharp.Tests.Processing.Filters
             Assert.Equal(5f, processor.Degrees);
         }
     }
-}
+}

tests/ImageSharp.Tests/Processing/Filters/InvertTest.cs

@@ -5,8 +5,9 @@ using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Filters;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Processing.Effects
+namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class InvertTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Filters/KodachromeTest.cs

@@ -7,6 +7,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class KodachromeTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Filters/LightnessTest.cs

@@ -5,8 +5,9 @@ using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Filters;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests.Processing.Effects
+namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
+    [Trait("Category", "Processors")]
     public class LightnessTest : BaseImageOperationsExtensionTest
     {
         [Fact]

tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs

@@ -1,15 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using SixLabors.ImageSharp.Tests.Processing;
-
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Filters;
 using Xunit;
 
-namespace SixLabors.ImageSharp.Tests
+namespace SixLabors.ImageSharp.Tests.Processing.Filters
 {
-    using SixLabors.ImageSharp.Processing;
-    using SixLabors.ImageSharp.Processing.Processors.Filters;
-
+    [Trait("Category", "Processors")]
     public class LomographTest : BaseImageOperationsExtensionTest
     {
         [Fact]