diff --git a/tests/ImageSharp.Tests/Processing/Binarization/DitherTests.cs b/tests/ImageSharp.Tests/Processing/Binarization/BinaryDitherTest.cs
similarity index 86%
rename from tests/ImageSharp.Tests/Processing/Binarization/DitherTests.cs
rename to tests/ImageSharp.Tests/Processing/Binarization/BinaryDitherTest.cs
index f801b2031..003f998d8 100644
--- a/tests/ImageSharp.Tests/Processing/Binarization/DitherTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Binarization/BinaryDitherTest.cs
@@ -8,19 +8,19 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Binarization
 {
-    public class DitherTest : BaseImageOperationsExtensionTest
+    public class BinaryDitherTest : BaseImageOperationsExtensionTest
     {
         private readonly IOrderedDither orderedDither;
         private readonly IErrorDiffuser errorDiffuser;
 
-        public DitherTest()
+        public BinaryDitherTest()
         {
             this.orderedDither = KnownDitherers.BayerDither4x4;
             this.errorDiffuser = KnownDiffusers.FloydSteinberg;
         }
 
         [Fact]
-        public void Dither_CorrectProcessor()
+        public void BinaryDither_CorrectProcessor()
         {
             this.operations.BinaryDither(this.orderedDither);
             BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>();
@@ -30,7 +30,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         }
 
         [Fact]
-        public void Dither_rect_CorrectProcessor()
+        public void BinaryDither_rect_CorrectProcessor()
         {
             this.operations.BinaryDither(this.orderedDither, this.rect);
             BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>(this.rect);
@@ -39,7 +39,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
             Assert.Equal(NamedColors<Rgba32>.Black, p.LowerColor);
         }
         [Fact]
-        public void Dither_index_CorrectProcessor()
+        public void BinaryDither_index_CorrectProcessor()
         {
             this.operations.BinaryDither(this.orderedDither, NamedColors<Rgba32>.Yellow, NamedColors<Rgba32>.HotPink);
             BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>();
@@ -49,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         }
 
         [Fact]
-        public void Dither_index_rect_CorrectProcessor()
+        public void BinaryDither_index_rect_CorrectProcessor()
         {
             this.operations.BinaryDither(this.orderedDither, NamedColors<Rgba32>.Yellow, NamedColors<Rgba32>.HotPink, this.rect);
             BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>(this.rect);
@@ -59,7 +59,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
 
 
         [Fact]
-        public void Dither_ErrorDiffuser_CorrectProcessor()
+        public void BinaryDither_ErrorDiffuser_CorrectProcessor()
         {
             this.operations.BinaryDiffuse(this.errorDiffuser, .4F);
             BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>();
@@ -70,7 +70,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         }
 
         [Fact]
-        public void Dither_ErrorDiffuser_rect_CorrectProcessor()
+        public void BinaryDither_ErrorDiffuser_rect_CorrectProcessor()
         {
             this.operations.BinaryDiffuse(this.errorDiffuser, .3F, this.rect);
             BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>(this.rect);
@@ -81,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         }
 
         [Fact]
-        public void Dither_ErrorDiffuser_CorrectProcessorWithColors()
+        public void BinaryDither_ErrorDiffuser_CorrectProcessorWithColors()
         {
             this.operations.BinaryDiffuse(this.errorDiffuser, .5F, NamedColors<Rgba32>.HotPink, NamedColors<Rgba32>.Yellow);
             BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>();
@@ -92,7 +92,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
         }
 
         [Fact]
-        public void Dither_ErrorDiffuser_rect_CorrectProcessorWithColors()
+        public void BinaryDither_ErrorDiffuser_rect_CorrectProcessorWithColors()
         {
             this.operations.BinaryDiffuse(this.errorDiffuser, .5F, NamedColors<Rgba32>.HotPink, NamedColors<Rgba32>.Yellow, this.rect);
             BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>(this.rect);
diff --git a/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs b/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs
new file mode 100644
index 000000000..03ae17848
--- /dev/null
+++ b/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs
@@ -0,0 +1,104 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Dithering;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Processors;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Processing.Binarization
+{
+    public class DitherTest : BaseImageOperationsExtensionTest
+    {
+        private readonly IOrderedDither orderedDither;
+        private readonly IErrorDiffuser errorDiffuser;
+        private readonly Rgba32[] TestPalette =
+        {
+            Rgba32.Red,
+            Rgba32.Green,
+            Rgba32.Blue
+        };
+
+        public DitherTest()
+        {
+            this.orderedDither = KnownDitherers.BayerDither4x4;
+            this.errorDiffuser = KnownDiffusers.FloydSteinberg;
+        }
+
+        [Fact]
+        public void Dither_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_rect_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither, this.rect);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+        [Fact]
+        public void Dither_index_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither, this.TestPalette);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_index_rect_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither, this.TestPalette, this.rect);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+
+
+        [Fact]
+        public void Dither_ErrorDiffuser_CorrectProcessor()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .4F);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.4F, p.Threshold);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_ErrorDiffuser_rect_CorrectProcessor()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .3F, this.rect);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.3F, p.Threshold);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_ErrorDiffuser_CorrectProcessorWithColors()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .5F, this.TestPalette);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.5F, p.Threshold);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_ErrorDiffuser_rect_CorrectProcessorWithColors()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .5F, this.TestPalette, this.rect);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.5F, p.Threshold);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Binarization/DitherTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
similarity index 94%
rename from tests/ImageSharp.Tests/Processing/Processors/Binarization/DitherTests.cs
rename to tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
index 6db1434c6..aec201239 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Binarization/DitherTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
@@ -11,7 +11,7 @@ using Xunit;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization
 {
-    public class DitherTests : FileTestBase
+    public class BinaryDitherTests : FileTestBase
     {
         public static readonly string[] CommonTestImages =
             {
@@ -47,7 +47,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization
         [Theory]
         [WithFileCollection(nameof(CommonTestImages), nameof(Ditherers), DefaultPixelType)]
         [WithTestPatternImages(nameof(Ditherers), 100, 100, DefaultPixelType)]
-        public void DitherFilter_WorksWithAllDitherers<TPixel>(TestImageProvider<TPixel> provider, string name, IOrderedDither ditherer)
+        public void BinaryDitherFilter_WorksWithAllDitherers<TPixel>(TestImageProvider<TPixel> provider, string name, IOrderedDither ditherer)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage())
@@ -72,7 +72,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization
 
         [Theory]
         [WithFile(TestImages.Png.Bike, CommonNonDefaultPixelTypes)]
-        public void DitherFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
+        public void BinaryDitherFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage())
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs
new file mode 100644
index 000000000..58c63d48c
--- /dev/null
+++ b/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs
@@ -0,0 +1,131 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Dithering;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
+
+using SixLabors.Primitives;
+using Xunit;
+// ReSharper disable InconsistentNaming
+
+namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization
+{
+    public class DitherTests : FileTestBase
+    {
+        public static readonly string[] CommonTestImages =
+            {
+                TestImages.Png.CalliphoraPartial, TestImages.Png.Bike
+            };
+
+        public static readonly TheoryData<string, IOrderedDither> Ditherers = new TheoryData<string, IOrderedDither>
+        {
+            { "Bayer8x8", KnownDitherers.BayerDither8x8 },
+            { "Bayer4x4", KnownDitherers.BayerDither4x4 },
+            { "Ordered3x3", KnownDitherers.OrderedDither3x3 },
+            { "Bayer2x2", KnownDitherers.BayerDither2x2 }
+        };
+
+        public static readonly TheoryData<string, IErrorDiffuser> ErrorDiffusers = new TheoryData<string, IErrorDiffuser>
+        {
+            { "Atkinson", KnownDiffusers.Atkinson },
+            { "Burks", KnownDiffusers.Burks },
+            { "FloydSteinberg", KnownDiffusers.FloydSteinberg },
+            { "JarvisJudiceNinke", KnownDiffusers.JarvisJudiceNinke },
+            { "Sierra2", KnownDiffusers.Sierra2 },
+            { "Sierra3", KnownDiffusers.Sierra3 },
+            { "SierraLite", KnownDiffusers.SierraLite },
+            { "StevensonArce", KnownDiffusers.StevensonArce },
+            { "Stucki", KnownDiffusers.Stucki },
+        };
+
+
+        private static IOrderedDither DefaultDitherer => KnownDitherers.BayerDither4x4;
+
+        private static IErrorDiffuser DefaultErrorDiffuser => KnownDiffusers.Atkinson;
+
+        [Theory]
+        [WithFileCollection(nameof(CommonTestImages), nameof(Ditherers), DefaultPixelType)]
+        [WithTestPatternImages(nameof(Ditherers), 100, 100, DefaultPixelType)]
+        public void DitherFilter_WorksWithAllDitherers<TPixel>(TestImageProvider<TPixel> provider, string name, IOrderedDither ditherer)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Dither(ditherer));
+                image.DebugSave(provider, name);
+            }
+        }
+
+        [Theory]
+        [WithFileCollection(nameof(CommonTestImages), nameof(ErrorDiffusers), DefaultPixelType)]
+        [WithTestPatternImages(nameof(ErrorDiffusers), 100, 100, DefaultPixelType)]
+        public void DiffusionFilter_WorksWithAllErrorDiffusers<TPixel>(TestImageProvider<TPixel> provider, string name, IErrorDiffuser diffuser)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Diffuse(diffuser, .5F));
+                image.DebugSave(provider, name);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.Bike, CommonNonDefaultPixelTypes)]
+        public void DitherFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Dither(DefaultDitherer));
+                image.DebugSave(provider);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.Bike, CommonNonDefaultPixelTypes)]
+        public void DiffusionFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Diffuse(DefaultErrorDiffuser, 0.5f));
+                image.DebugSave(provider);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.CalliphoraPartial, DefaultPixelType)]
+        public void ApplyDitherFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = source.Clone())
+            {
+                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+
+                image.Mutate(x => x.Dither(DefaultDitherer, bounds));
+                image.DebugSave(provider);
+
+                ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.CalliphoraPartial, DefaultPixelType)]
+        public void ApplyDiffusionFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = source.Clone())
+            {
+                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+
+                image.Mutate(x => x.Diffuse(DefaultErrorDiffuser, .5F, bounds));
+                image.DebugSave(provider);
+
+                ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
+            }
+        }
+    }
+}
\ No newline at end of file