opti: remove redundant tests before creating MagickGeometry

src/Magick.NET/MagickImage.cs

@@ -3458,8 +3458,6 @@ public void InterpolativeResize(IMagickGeometry geometry, PixelInterpolateMethod
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void InterpolativeResize(Percentage percentage, PixelInterpolateMethod method)
     {
-        Throw.IfNegative(nameof(percentage), percentage);
-
         var geometry = new MagickGeometry(percentage, percentage);
         InterpolativeResize(geometry, method);
     }
@@ -3473,9 +3471,6 @@ public void InterpolativeResize(Percentage percentage, PixelInterpolateMethod me
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void InterpolativeResize(Percentage percentageWidth, Percentage percentageHeight, PixelInterpolateMethod method)
     {
-        Throw.IfNegative(nameof(percentageWidth), percentageWidth);
-        Throw.IfNegative(nameof(percentageHeight), percentageHeight);
-
         var geometry = new MagickGeometry(percentageWidth, percentageHeight);
         InterpolativeResize(geometry, method);
     }
@@ -3931,8 +3926,6 @@ public void LiquidRescale(IMagickGeometry geometry)
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void LiquidRescale(Percentage percentage)
     {
-        Throw.IfNegative(nameof(percentage), percentage);
-
         var geometry = new MagickGeometry(percentage, percentage);
         LiquidRescale(geometry);
     }
@@ -3945,9 +3938,6 @@ public void LiquidRescale(Percentage percentage)
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void LiquidRescale(Percentage percentageWidth, Percentage percentageHeight)
     {
-        Throw.IfNegative(nameof(percentageWidth), percentageWidth);
-        Throw.IfNegative(nameof(percentageHeight), percentageHeight);
-
         var geometry = new MagickGeometry(percentageWidth, percentageHeight);
         LiquidRescale(geometry);
     }
@@ -3962,9 +3952,6 @@ public void LiquidRescale(Percentage percentageWidth, Percentage percentageHeigh
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void LiquidRescale(Percentage percentageWidth, Percentage percentageHeight, double deltaX, double rigidity)
     {
-        Throw.IfNegative(nameof(percentageWidth), percentageWidth);
-        Throw.IfNegative(nameof(percentageHeight), percentageHeight);
-
         var geometry = new MagickGeometry(percentageWidth, percentageHeight);
 
         _nativeInstance.LiquidRescale(geometry.ToString(), deltaX, rigidity);
@@ -5520,8 +5507,6 @@ public void Resize(IMagickGeometry geometry)
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void Resize(Percentage percentage)
     {
-        Throw.IfNegative(nameof(percentage), percentage);
-
         var geometry = new MagickGeometry(percentage, percentage);
         Resize(geometry);
     }
@@ -5534,9 +5519,6 @@ public void Resize(Percentage percentage)
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void Resize(Percentage percentageWidth, Percentage percentageHeight)
     {
-        Throw.IfNegative(nameof(percentageWidth), percentageWidth);
-        Throw.IfNegative(nameof(percentageHeight), percentageHeight);
-
         var geometry = new MagickGeometry(percentageWidth, percentageHeight);
         Resize(geometry);
     }
@@ -5615,12 +5597,7 @@ public void Sample(Percentage percentage)
     /// <param name="percentageHeight">The percentage of the height.</param>
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void Sample(Percentage percentageWidth, Percentage percentageHeight)
-    {
-        Throw.IfNegative(nameof(percentageWidth), percentageWidth);
-        Throw.IfNegative(nameof(percentageHeight), percentageHeight);
-
-        Sample(new MagickGeometry(percentageWidth, percentageHeight));
-    }
+        => Sample(new MagickGeometry(percentageWidth, percentageHeight));
 
     /// <summary>
     /// Resize image by using simple ratio algorithm.
@@ -5661,12 +5638,7 @@ public void Scale(Percentage percentage)
     /// <param name="percentageHeight">The percentage of the height.</param>
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void Scale(Percentage percentageWidth, Percentage percentageHeight)
-    {
-        Throw.IfNegative(nameof(percentageWidth), percentageWidth);
-        Throw.IfNegative(nameof(percentageHeight), percentageHeight);
-
-        Scale(new MagickGeometry(percentageWidth, percentageHeight));
-    }
+        => Scale(new MagickGeometry(percentageWidth, percentageHeight));
 
     /// <summary>
     /// Segment (coalesce similar image components) by analyzing the histograms of the color
@@ -6512,9 +6484,6 @@ public void Thumbnail(Percentage percentage)
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void Thumbnail(Percentage percentageWidth, Percentage percentageHeight)
     {
-        Throw.IfNegative(nameof(percentageWidth), percentageWidth);
-        Throw.IfNegative(nameof(percentageHeight), percentageHeight);
-
         var geometry = new MagickGeometry(percentageWidth, percentageHeight);
         Thumbnail(geometry);
     }

tests/Magick.NET.Tests/Factories/MagickGeometryFactoryTests/TheCreateMethod.cs

@@ -218,5 +218,40 @@ public void ShouldSetXAndYAndIsPercentage()
             Assert.Equal(20, geometry.Height);
             Assert.True(geometry.IsPercentage);
         }
+
+        [Fact]
+        public void ShouldThrowExceptionWhenWidthAndHeightIsNegative()
+        {
+            var factory = new MagickGeometryFactory();
+
+            Assert.Throws<ArgumentException>("width", () => factory.Create(-1));
+        }
+
+        [Fact]
+        public void ShouldThrowExceptionWhenWidthIsNegative()
+        {
+            var factory = new MagickGeometryFactory();
+
+            Assert.Throws<ArgumentException>("width", () => factory.Create(-1, 10));
+            Assert.Throws<ArgumentException>("width", () => factory.Create(0, 0, -1, 10));
+        }
+
+        [Fact]
+        public void ShouldThrowExceptionWhenHeightIsNegative()
+        {
+            var factory = new MagickGeometryFactory();
+
+            Assert.Throws<ArgumentException>("height", () => factory.Create(5, -1));
+            Assert.Throws<ArgumentException>("height", () => factory.Create(0, 0, 5, -1));
+        }
+
+        [Fact]
+        public void ShouldThrowExceptionWhenPercentageIsNegative()
+        {
+            var factory = new MagickGeometryFactory();
+
+            Assert.Throws<ArgumentException>("percentageWidth", () => factory.Create(new Percentage(-1), new Percentage(10)));
+            Assert.Throws<ArgumentException>("percentageHeight", () => factory.Create(new Percentage(10), new Percentage(-1)));
+        }
     }
 }

tests/Magick.NET.Tests/MagickImageTests/TheAdaptiveResizeMethod.cs

@@ -1,6 +1,7 @@
 // Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using ImageMagick;
 using Xunit;
 
@@ -10,6 +11,20 @@ public partial class MagickImageTests
 {
     public class TheAdaptiveResizeMethod
     {
+        [Fact]
+        public void ShouldThrowExceptionWhenWidthIsNegative()
+        {
+            using var image = new MagickImage(Files.MagickNETIconPNG);
+            Assert.Throws<ArgumentException>("width", () => image.AdaptiveResize(-1, 512));
+        }
+
+        [Fact]
+        public void ShouldThrowExceptionWhenHeightIsNegative()
+        {
+            using var image = new MagickImage(Files.MagickNETIconPNG);
+            Assert.Throws<ArgumentException>("height", () => image.AdaptiveResize(512, -1));
+        }
+
         [Fact]
         public void ShouldNotEnlargeTheImage()
         {

tests/Magick.NET.Tests/MagickImageTests/TheChopMethod.cs

@@ -29,4 +29,24 @@ public void ShouldChopTheImage()
             Assert.Equal(320, image.Height);
         }
     }
+
+    public class TheChopHorizontalMethod
+    {
+        [Fact]
+        public void ShouldThrowExceptionWhenWidthIsNegative()
+        {
+            using var image = new MagickImage(Files.Builtin.Wizard);
+            Assert.Throws<ArgumentException>("width", () => image.ChopHorizontal(-1, -1));
+        }
+    }
+
+    public class TheChopVerticalMethod
+    {
+        [Fact]
+        public void ShouldThrowExceptionWhenHeightIsNegative()
+        {
+            using var image = new MagickImage(Files.Builtin.Wizard);
+            Assert.Throws<ArgumentException>("height", () => image.ChopVertical(-1, -1));
+        }
+    }
 }

tests/Magick.NET.Tests/MagickImageTests/TheCloneMethod.cs

@@ -1,6 +1,7 @@
 // Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using ImageMagick;
 using Xunit;
 
@@ -10,6 +11,34 @@ public partial class MagickImageTests
 {
     public class TheCloneMethod
     {
+        [Fact]
+        public void ShouldThrowExceptionWhenWidthIsNegative()
+        {
+            {
+                using var image = new MagickImage(Files.MagickNETIconPNG);
+                Assert.Throws<ArgumentException>("width", () => image.Clone(-1, 64));
+            }
+
+            {
+                using var image = new MagickImage(Files.MagickNETIconPNG);
+                Assert.Throws<ArgumentException>("width", () => image.Clone(0, 0, -1, 64));
+            }
+        }
+
+        [Fact]
+        public void ShouldThrowExceptionWhenHeightIsNegative()
+        {
+            {
+                using var image = new MagickImage(Files.MagickNETIconPNG);
+                Assert.Throws<ArgumentException>("height", () => image.Clone(32, -1));
+            }
+
+            {
+                using var image = new MagickImage(Files.MagickNETIconPNG);
+                Assert.Throws<ArgumentException>("height", () => image.Clone(0, 0, 32, -1));
+            }
+        }
+
         [Fact]
         public void ShouldThrowExceptionWhenNoImageIsRead()
         {

tests/Magick.NET.Tests/MagickImageTests/TheCropMethod.cs

@@ -1,6 +1,7 @@
 // Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using ImageMagick;
 using Xunit;
 
@@ -10,6 +11,34 @@ public partial class MagickImageTests
 {
     public class TheCropMethod
     {
+        [Fact]
+        public void ShouldThrowExceptionWhenWidthIsNegative()
+        {
+            {
+                using var image = new MagickImage(Files.Builtin.Logo);
+                Assert.Throws<ArgumentException>("width", () => image.Crop(-1, 50));
+            }
+
+            {
+                using var image = new MagickImage(Files.Builtin.Logo);
+                Assert.Throws<ArgumentException>("width", () => image.Crop(-1, 50, Gravity.Center));
+            }
+        }
+
+        [Fact]
+        public void ShouldThrowExceptionWhenHeightIsNegative()
+        {
+            {
+                using var image = new MagickImage(Files.Builtin.Logo);
+                Assert.Throws<ArgumentException>("height", () => image.Crop(40, -1));
+            }
+
+            {
+                using var image = new MagickImage(Files.Builtin.Logo);
+                Assert.Throws<ArgumentException>("height", () => image.Crop(40, -1, Gravity.Center));
+            }
+        }
+
         [Fact]
         public void ShouldSetImageToCorrectDimensions()
         {

tests/Magick.NET.Tests/MagickImageTests/TheExtentMethod.cs

@@ -13,6 +13,64 @@ public class TheExtentMethod
     {
         public class WithWidthAndHeight
         {
+            [Fact]
+            public void ShouldThrowExceptionWhenWidthIsNegative()
+            {
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("width", () => image.Extent(-1, 3));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("width", () => image.Extent(2, 3, -1, 3));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("width", () => image.Extent(-1, 3, MagickColors.Purple));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("width", () => image.Extent(-1, 3, Gravity.Center));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("width", () => image.Extent(-1, 3, Gravity.Center, MagickColors.Purple));
+                }
+            }
+
+            [Fact]
+            public void ShouldThrowExceptionWhenHeightIsNegative()
+            {
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("height", () => image.Extent(2, -1));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("height", () => image.Extent(2, 3, 2, -1));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("height", () => image.Extent(2, -1, MagickColors.Purple));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("height", () => image.Extent(2, -1, Gravity.Center));
+                }
+
+                {
+                    using var image = new MagickImage(MagickColors.Black, 1, 1);
+                    Assert.Throws<ArgumentException>("height", () => image.Extent(2, -1, Gravity.Center, MagickColors.Purple));
+                }
+            }
+
             [Fact]
             public void ShouldExtentTheImage()
             {