Throw ObjectDisposedException when trying to operate on a disposed image (SixLabors#968)

* disable multitargeting + TreatWarningsAsErrors to for fast development

* Check if image is disposed

in significant Image and Image<T> methods

* Mutate / Clone: ensure image is not disposed

* Revert "disable multitargeting + TreatWarningsAsErrors to for fast development"

This reverts commit 9ad74f7.

Author: antonfirsov

tests/ImageSharp.Tests/ImageOperationTests.cs

@@ -23,19 +23,22 @@ public class ImageOperationTests : IDisposable
         private readonly FakeImageOperationsProvider provider;
         private readonly IImageProcessor processorDefinition;
 
+        private static readonly string ExpectedExceptionMessage = GetExpectedExceptionText();
+
         public ImageOperationTests()
         {
             this.provider = new FakeImageOperationsProvider();
 
             Mock<IImageProcessor> processorMock = new Mock<IImageProcessor>();
             this.processorDefinition = processorMock.Object;
-            
+
             this.image = new Image<Rgba32>(new Configuration
             {
                 ImageOperationsProvider = this.provider
             }, 1, 1);
         }
 
+
         [Fact]
         public void MutateCallsImageOperationsProvider_Func_OriginalImage()
         {
@@ -109,5 +112,65 @@ public void ApplyProcessors_ListOfProcessors_AppliesAllProcessorsToOperation()
         }
 
         public void Dispose() => this.image.Dispose();
+
+        [Fact]
+        public void GenericMutate_WhenDisposed_Throws()
+        {
+            this.image.Dispose();
+
+            CheckThrowsCorrectObjectDisposedException(
+                () => this.image.Mutate(x => x.ApplyProcessor(this.processorDefinition)));
+        }
+
+        [Fact]
+        public void GenericClone_WhenDisposed_Throws()
+        {
+            this.image.Dispose();
+
+            CheckThrowsCorrectObjectDisposedException(
+                () => this.image.Clone(x => x.ApplyProcessor(this.processorDefinition)));
+        }
+
+        [Fact]
+        public void AgnosticMutate_WhenDisposed_Throws()
+        {
+            this.image.Dispose();
+            Image img = this.image;
+
+            CheckThrowsCorrectObjectDisposedException(
+                () => img.Mutate(x => x.ApplyProcessor(this.processorDefinition)));
+        }
+
+        [Fact]
+        public void AgnosticClone_WhenDisposed_Throws()
+        {
+            this.image.Dispose();
+            Image img = this.image;
+
+            CheckThrowsCorrectObjectDisposedException(
+                () => img.Clone(x => x.ApplyProcessor(this.processorDefinition)));
+        }
+
+        private static string GetExpectedExceptionText()
+        {
+            try
+            {
+                Image<Rgba32> img = new Image<Rgba32>(1, 1);
+                img.Dispose();
+                img.EnsureNotDisposed();
+            }
+            catch (ObjectDisposedException ex)
+            {
+                return ex.Message;
+            }
+
+            return "?";
+        }
+
+        private static void CheckThrowsCorrectObjectDisposedException(Action action)
+        {
+            var ex = Assert.Throws<ObjectDisposedException>(action);
+            Assert.Equal(ExpectedExceptionMessage, ex.Message);
+        }
     }
 }