diff --git a/src/Magick.NET/MagickImage.cs b/src/Magick.NET/MagickImage.cs index 1e62ccfaab..d6d7ec1335 100644 --- a/src/Magick.NET/MagickImage.cs +++ b/src/Magick.NET/MagickImage.cs @@ -3458,8 +3458,6 @@ public void InterpolativeResize(IMagickGeometry geometry, PixelInterpolateMethod /// Thrown when an error is raised by ImageMagick. 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 /// Thrown when an error is raised by ImageMagick. 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) /// Thrown when an error is raised by ImageMagick. 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) /// Thrown when an error is raised by ImageMagick. 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 /// Thrown when an error is raised by ImageMagick. 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) /// Thrown when an error is raised by ImageMagick. 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) /// Thrown when an error is raised by ImageMagick. 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) /// The percentage of the height. /// Thrown when an error is raised by ImageMagick. 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)); /// /// Resize image by using simple ratio algorithm. @@ -5661,12 +5638,7 @@ public void Scale(Percentage percentage) /// The percentage of the height. /// Thrown when an error is raised by ImageMagick. 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)); /// /// Segment (coalesce similar image components) by analyzing the histograms of the color @@ -6512,9 +6484,6 @@ public void Thumbnail(Percentage percentage) /// Thrown when an error is raised by ImageMagick. 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); } diff --git a/tests/Magick.NET.Tests/Factories/MagickGeometryFactoryTests/TheCreateMethod.cs b/tests/Magick.NET.Tests/Factories/MagickGeometryFactoryTests/TheCreateMethod.cs index 0fde91708a..71ac6a87ac 100644 --- a/tests/Magick.NET.Tests/Factories/MagickGeometryFactoryTests/TheCreateMethod.cs +++ b/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("width", () => factory.Create(-1)); + } + + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + var factory = new MagickGeometryFactory(); + + Assert.Throws("width", () => factory.Create(-1, 10)); + Assert.Throws("width", () => factory.Create(0, 0, -1, 10)); + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + var factory = new MagickGeometryFactory(); + + Assert.Throws("height", () => factory.Create(5, -1)); + Assert.Throws("height", () => factory.Create(0, 0, 5, -1)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageIsNegative() + { + var factory = new MagickGeometryFactory(); + + Assert.Throws("percentageWidth", () => factory.Create(new Percentage(-1), new Percentage(10))); + Assert.Throws("percentageHeight", () => factory.Create(new Percentage(10), new Percentage(-1))); + } } } diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheAdaptiveResizeMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheAdaptiveResizeMethod.cs index faf909a8eb..47db6c7a0e 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheAdaptiveResizeMethod.cs +++ b/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("width", () => image.AdaptiveResize(-1, 512)); + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("height", () => image.AdaptiveResize(512, -1)); + } + [Fact] public void ShouldNotEnlargeTheImage() { diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheChopMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheChopMethod.cs index 723e5ec5ef..8905df7333 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheChopMethod.cs +++ b/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("width", () => image.ChopHorizontal(-1, -1)); + } + } + + public class TheChopVerticalMethod + { + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.Builtin.Wizard); + Assert.Throws("height", () => image.ChopVertical(-1, -1)); + } + } } diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheCloneMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheCloneMethod.cs index 7cd95c16b5..9d62051c72 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheCloneMethod.cs +++ b/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("width", () => image.Clone(-1, 64)); + } + + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("width", () => image.Clone(0, 0, -1, 64)); + } + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("height", () => image.Clone(32, -1)); + } + + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("height", () => image.Clone(0, 0, 32, -1)); + } + } + [Fact] public void ShouldThrowExceptionWhenNoImageIsRead() { diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheCropMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheCropMethod.cs index 9847dfac79..2d9039d5a6 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheCropMethod.cs +++ b/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("width", () => image.Crop(-1, 50)); + } + + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("width", () => image.Crop(-1, 50, Gravity.Center)); + } + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("height", () => image.Crop(40, -1)); + } + + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("height", () => image.Crop(40, -1, Gravity.Center)); + } + } + [Fact] public void ShouldSetImageToCorrectDimensions() { diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheExtentMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheExtentMethod.cs index 7da4f1c535..e721e84e46 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheExtentMethod.cs +++ b/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("width", () => image.Extent(-1, 3)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("width", () => image.Extent(2, 3, -1, 3)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("width", () => image.Extent(-1, 3, MagickColors.Purple)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("width", () => image.Extent(-1, 3, Gravity.Center)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("width", () => image.Extent(-1, 3, Gravity.Center, MagickColors.Purple)); + } + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("height", () => image.Extent(2, -1)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("height", () => image.Extent(2, 3, 2, -1)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("height", () => image.Extent(2, -1, MagickColors.Purple)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("height", () => image.Extent(2, -1, Gravity.Center)); + } + + { + using var image = new MagickImage(MagickColors.Black, 1, 1); + Assert.Throws("height", () => image.Extent(2, -1, Gravity.Center, MagickColors.Purple)); + } + } + [Fact] public void ShouldExtentTheImage() { diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheFrameMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheFrameMethod.cs index 23b49b1de8..0ab0831b40 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheFrameMethod.cs +++ b/tests/Magick.NET.Tests/MagickImageTests/TheFrameMethod.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 TheFrameMethod { + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("width", () => image.Frame(-1, 100)); + } + + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("width", () => image.Frame(-1, 100, 6, 6)); + } + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("height", () => image.Frame(100, -1)); + } + + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("height", () => image.Frame(100, -1, 6, 6)); + } + } + [Fact] public void ShouldFrameTheImage() { @@ -42,10 +71,7 @@ public void ShouldNotMakeImageLargerWithBevel() public void ShouldThrowExceptionWhenFrameIsLessThanImageSize() { using var image = new MagickImage(Files.MagickNETIconPNG); - var exception = Assert.Throws(() => - { - image.Frame(6, 6, 7, 7); - }); + var exception = Assert.Throws(() => { image.Frame(6, 6, 7, 7); }); Assert.Contains("frame is less than image size", exception.Message); } diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheInterpolativeResizeMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheInterpolativeResizeMethod.cs index 03fb07f5f3..c6a2391c74 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheInterpolativeResizeMethod.cs +++ b/tests/Magick.NET.Tests/MagickImageTests/TheInterpolativeResizeMethod.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,41 @@ public partial class MagickImageTests { public class TheInterpolativeResizeMethod { + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + using var image = new MagickImage(Files.RedPNG); + Assert.Throws("width", () => image.InterpolativeResize(-1, 32, PixelInterpolateMethod.Mesh)); + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.RedPNG); + Assert.Throws("height", () => image.InterpolativeResize(32, -1, PixelInterpolateMethod.Mesh)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageIsNegative() + { + using var image = new MagickImage(Files.RedPNG); + Assert.Throws("percentageWidth", () => image.InterpolativeResize(new Percentage(-1), PixelInterpolateMethod.Mesh)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageWidthIsNegative() + { + using var image = new MagickImage(Files.RedPNG); + Assert.Throws("percentageWidth", () => image.InterpolativeResize(new Percentage(-1), new Percentage(10), PixelInterpolateMethod.Mesh)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageHeightIsNegative() + { + using var image = new MagickImage(Files.RedPNG); + Assert.Throws("percentageHeight", () => image.InterpolativeResize(new Percentage(10), new Percentage(-1), PixelInterpolateMethod.Mesh)); + } + [Fact] public void ShouldResizeTheImage() { diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheLiquidRescaleMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheLiquidRescaleMethod.cs index fa1b16e1bd..daa19999b5 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheLiquidRescaleMethod.cs +++ b/tests/Magick.NET.Tests/MagickImageTests/TheLiquidRescaleMethod.cs @@ -22,6 +22,20 @@ public void ShouldResizeTheImage() Assert.Equal(64, image.Width); Assert.Equal(64, image.Height); } + + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("width", () => image.LiquidRescale(-1, 64)); + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("height", () => image.LiquidRescale(64, -1)); + } } public class WithWidthAndHeightAndRigidity @@ -42,6 +56,20 @@ public void ShouldApplyTheRigidity() Assert.InRange(image.Compare(otherWithRigidity, ErrorMetric.RootMeanSquared), 0.3, 0.4); } + + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("width", () => image.LiquidRescale(-1, 64, 5.0, 0.0)); + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.MagickNETIconPNG); + Assert.Throws("height", () => image.LiquidRescale(64, -1, 5.0, 0.0)); + } } public class WithGeometry @@ -74,25 +102,27 @@ public class WithPercentage [Fact] public void ShouldThrowExceptionWhenPercentageIsNegative() { + var percentage = new Percentage(-1); using var image = new MagickImage(Files.MagickNETIconPNG); - - Assert.Throws("percentage", () => image.LiquidRescale(new Percentage(-1))); + Assert.Throws("percentageWidth", () => image.LiquidRescale(percentage)); } [Fact] public void ShouldThrowExceptionWhenPercentageWidthIsNegative() { + var percentageWidth = new Percentage(-1); + var percentageHeight = new Percentage(1); using var image = new MagickImage(Files.MagickNETIconPNG); - - Assert.Throws("percentageWidth", () => image.LiquidRescale(new Percentage(-1), new Percentage(1))); + Assert.Throws("percentageWidth", () => image.LiquidRescale(percentageWidth, percentageHeight)); } [Fact] public void ShouldThrowExceptionWhenPercentageHeightIsNegative() { + var percentageWidth = new Percentage(1); + var percentageHeight = new Percentage(-1); using var image = new MagickImage(Files.MagickNETIconPNG); - - Assert.Throws("percentageHeight", () => image.LiquidRescale(new Percentage(1), new Percentage(-1))); + Assert.Throws("percentageHeight", () => image.LiquidRescale(percentageWidth, percentageHeight)); } [Fact] diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheResizeMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheResizeMethod.cs index 6a0ef8f42b..0aaf29e391 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheResizeMethod.cs +++ b/tests/Magick.NET.Tests/MagickImageTests/TheResizeMethod.cs @@ -99,7 +99,27 @@ public void ShouldThrowExceptionWhenPercentageIsNegative() var percentage = new Percentage(-0.5); using var image = new MagickImage(Files.MagickNETIconPNG); - Assert.Throws("percentage", () => image.Resize(percentage)); + Assert.Throws("percentageWidth", () => image.Resize(percentage)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageWidthIsNegative() + { + var percentageWidth = new Percentage(-0.5); + var percentageHeight = new Percentage(10); + using var image = new MagickImage(Files.MagickNETIconPNG); + + Assert.Throws("percentageWidth", () => image.Resize(percentageWidth, percentageHeight)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageHeightIsNegative() + { + var percentageWidth = new Percentage(10); + var percentageHeight = new Percentage(-0.5); + using var image = new MagickImage(Files.MagickNETIconPNG); + + Assert.Throws("percentageHeight", () => image.Resize(percentageWidth, percentageHeight)); } [Fact] @@ -115,6 +135,20 @@ public void ShouldResizeTheImage() public class WithWidthAndHeight { + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + using var image = new MagickImage(Files.RedPNG); + Assert.Throws("width", () => image.Resize(-1, 32)); + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.RedPNG); + Assert.Throws("height", () => image.Resize(32, -1)); + } + [Fact] public void ShouldResizeTheImage() { diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheSampleMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheSampleMethod.cs index 676bffd1ee..511d5138e2 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheSampleMethod.cs +++ b/tests/Magick.NET.Tests/MagickImageTests/TheSampleMethod.cs @@ -11,42 +11,94 @@ public partial class MagickImageTests { public class TheSampleMethod { - [Fact] - public void ShouldThrowExceptionWhenGeometryIsNull() + public class WithGeometry { - using var image = new MagickImage(); + [Fact] + public void ShouldThrowExceptionWhenGeometryIsNull() + { + using var image = new MagickImage(); - Assert.Throws("geometry", () => image.Sample(null)); - } + Assert.Throws("geometry", () => image.Sample(null)); + } - [Fact] - public void ShouldResizeTheImage() - { - using var image = new MagickImage(Files.Builtin.Logo); - image.Sample(400, 400); + [Fact] + public void ShouldUseTheSpecifiedGeometry() + { + using var image = new MagickImage(Files.Builtin.Logo); + image.Sample(new MagickGeometry(300, 300)); - Assert.Equal(400, image.Width); - Assert.Equal(300, image.Height); + Assert.Equal(300, image.Width); + Assert.Equal(225, image.Height); + } } - [Fact] - public void ShouldUseTheSpecifiedGeometry() + public class WithWidthAndHeight { - using var image = new MagickImage(Files.Builtin.Logo); - image.Sample(new MagickGeometry(300, 300)); + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("width", () => image.Sample(-1, 400)); + } + + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("height", () => image.Sample(400, -1)); + } - Assert.Equal(300, image.Width); - Assert.Equal(225, image.Height); + [Fact] + public void ShouldResizeTheImage() + { + using var image = new MagickImage(Files.Builtin.Logo); + image.Sample(400, 400); + + Assert.Equal(400, image.Width); + Assert.Equal(300, image.Height); + } } - [Fact] - public void ShouldUseTheSpecifiedPercentage() + public class WithPercentage { - using var image = new MagickImage(Files.Builtin.Logo); - image.Sample(new Percentage(50)); + [Fact] + public void ShouldThrowExceptionWhenPercentageIsNegative() + { + var percentage = new Percentage(-0.5); + using var image = new MagickImage(Files.Builtin.Logo); + + Assert.Throws("percentageWidth", () => image.Sample(percentage)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageWidthIsNegative() + { + var percentageWidth = new Percentage(-0.5); + var percentageHeight = new Percentage(10); + using var image = new MagickImage(Files.Builtin.Logo); + + Assert.Throws("percentageWidth", () => image.Sample(percentageWidth, percentageHeight)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageHeightIsNegative() + { + var percentageWidth = new Percentage(10); + var percentageHeight = new Percentage(-0.5); + using var image = new MagickImage(Files.Builtin.Logo); + + Assert.Throws("percentageHeight", () => image.Sample(percentageWidth, percentageHeight)); + } + + [Fact] + public void ShouldUseTheSpecifiedPercentage() + { + using var image = new MagickImage(Files.Builtin.Logo); + image.Sample(new Percentage(50)); - Assert.Equal(320, image.Width); - Assert.Equal(240, image.Height); + Assert.Equal(320, image.Width); + Assert.Equal(240, image.Height); + } } } } diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheScaleMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheScaleMethod.cs index 5664507042..5b77ab2f77 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheScaleMethod.cs +++ b/tests/Magick.NET.Tests/MagickImageTests/TheScaleMethod.cs @@ -11,55 +11,107 @@ public partial class MagickImageTests { public class TheScaleMethod { - [Fact] - public void ShouldThrowExceptionWhenGeometryIsNull() + public class WithGeometry { - using var image = new MagickImage(); + [Fact] + public void ShouldThrowExceptionWhenGeometryIsNull() + { + using var image = new MagickImage(); - Assert.Throws("geometry", () => image.Scale(null)); - } + Assert.Throws("geometry", () => image.Scale(null)); + } - [Fact] - public void ShouldResizeTheImage() - { - using var image = new MagickImage(Files.Builtin.Logo); - image.Scale(400, 400); + [Fact] + public void ShouldUseTheSpecifiedGeometry() + { + using var image = new MagickImage(Files.Builtin.Logo); + image.Scale(new MagickGeometry(300, 300)); - Assert.Equal(400, image.Width); - Assert.Equal(300, image.Height); + Assert.Equal(300, image.Width); + Assert.Equal(225, image.Height); + } } - [Fact] - public void ShouldUseTheSpecifiedGeometry() + public class WithWidthAndHeight { - using var image = new MagickImage(Files.Builtin.Logo); - image.Scale(new MagickGeometry(300, 300)); + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("width", () => image.Scale(-1, 400)); + } - Assert.Equal(300, image.Width); - Assert.Equal(225, image.Height); - } + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("height", () => image.Scale(400, -1)); + } - [Fact] - public void ShouldUseTheSpecifiedPercentage() - { - using var image = new MagickImage(Files.Builtin.Logo); - image.Scale(new Percentage(50)); + [Fact] + public void ShouldResizeTheImage() + { + using var image = new MagickImage(Files.Builtin.Logo); + image.Scale(400, 400); - Assert.Equal(320, image.Width); - Assert.Equal(240, image.Height); + Assert.Equal(400, image.Width); + Assert.Equal(300, image.Height); + } } - [Fact] - public void ShouldUseSimpleResizeAlgorithm() + public class WithPercentage { - using var image = new MagickImage(Files.CirclePNG); - var color = MagickColor.FromRgba(255, 255, 255, 159); + [Fact] + public void ShouldThrowExceptionWhenPercentageIsNegative() + { + var percentage = new Percentage(-0.5); + using var image = new MagickImage(Files.Builtin.Logo); + + Assert.Throws("percentageWidth", () => image.Scale(percentage)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageWidthIsNegative() + { + var percentageWidth = new Percentage(-0.5); + var percentageHeight = new Percentage(10); + using var image = new MagickImage(Files.Builtin.Logo); + + Assert.Throws("percentageWidth", () => image.Scale(percentageWidth, percentageHeight)); + } + + [Fact] + public void ShouldThrowExceptionWhenPercentageHeightIsNegative() + { + var percentageWidth = new Percentage(10); + var percentageHeight = new Percentage(-0.5); + using var image = new MagickImage(Files.Builtin.Logo); + + Assert.Throws("percentageHeight", () => image.Scale(percentageWidth, percentageHeight)); + } + + [Fact] + public void ShouldUseTheSpecifiedPercentage() + { + using var image = new MagickImage(Files.Builtin.Logo); + image.Scale(new Percentage(50)); + + Assert.Equal(320, image.Width); + Assert.Equal(240, image.Height); + } + + [Fact] + public void ShouldUseSimpleResizeAlgorithm() + { + using var image = new MagickImage(Files.CirclePNG); + var color = MagickColor.FromRgba(255, 255, 255, 159); - ColorAssert.Equal(color, image, image.Width / 2, image.Height / 2); + ColorAssert.Equal(color, image, image.Width / 2, image.Height / 2); - image.Scale((Percentage)400); + image.Scale((Percentage)400); - ColorAssert.Equal(color, image, image.Width / 2, image.Height / 2); + ColorAssert.Equal(color, image, image.Width / 2, image.Height / 2); + } } } } diff --git a/tests/Magick.NET.Tests/MagickImageTests/TheThumbnailMethod.cs b/tests/Magick.NET.Tests/MagickImageTests/TheThumbnailMethod.cs index 741f3730d7..f4ee1dd72c 100644 --- a/tests/Magick.NET.Tests/MagickImageTests/TheThumbnailMethod.cs +++ b/tests/Magick.NET.Tests/MagickImageTests/TheThumbnailMethod.cs @@ -11,59 +11,91 @@ public partial class MagickImageTests { public class TheThumbnailMethod { - [Fact] - public void ShouldThrowExceptionWhenGeometryIsNull() + public class WithGeometry { - using var image = new MagickImage(); + [Fact] + public void ShouldThrowExceptionWhenGeometryIsNull() + { + using var image = new MagickImage(); + Assert.Throws("geometry", () => image.Thumbnail(null)); + } - Assert.Throws("geometry", () => image.Thumbnail(null)); - } - - [Fact] - public void ShouldThrowExceptionWhenPercentageWidthIsNegative() - { - using var image = new MagickImage(); + [Fact] + public void ShouldResizeTheImageToTheCorrectDimensions() + { + var geometry = new MagickGeometry("1x1+0+0>"); + using var image = new MagickImage(Files.SnakewarePNG); + image.Thumbnail(geometry); - Assert.Throws("percentageWidth", () => image.Thumbnail(new Percentage(-1), new Percentage(1))); + Assert.Equal(1, image.Width); + Assert.Equal(1, image.Height); + } } - [Fact] - public void ShouldThrowExceptionWhenPercentageHeightIsNegative() + public class WithWidthAndHeight { - using var image = new MagickImage(); + [Fact] + public void ShouldThrowExceptionWhenWidthIsNegative() + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("width", () => image.Thumbnail(-1, 100)); + } - Assert.Throws("percentageHeight", () => image.Thumbnail(new Percentage(1), new Percentage(-1))); - } + [Fact] + public void ShouldThrowExceptionWhenHeightIsNegative() + { + using var image = new MagickImage(Files.Builtin.Logo); + Assert.Throws("height", () => image.Thumbnail(100, -1)); + } - [Fact] - public void ShouldCreateThumbnailOfTheImage() - { - using var image = new MagickImage(Files.SnakewarePNG); - image.Thumbnail(100, 100); + [Fact] + public void ShouldCreateThumbnailOfTheImage() + { + using var image = new MagickImage(Files.SnakewarePNG); + image.Thumbnail(100, 100); - Assert.Equal(100, image.Width); - Assert.Equal(23, image.Height); + Assert.Equal(100, image.Width); + Assert.Equal(23, image.Height); + } } - [Fact] - public void ShouldCreateThumbnailOfTheImageWithTheSpecifiedPercentage() + public class WithPercentage { - using var image = new MagickImage(Files.Builtin.Logo); - image.Thumbnail(new Percentage(50)); + [Fact] + public void ShouldThrowExceptionWhenPercentageIsNegative() + { + var percentage = new Percentage(-0.5); + using var image = new MagickImage(); + Assert.Throws("percentageWidth", () => image.Thumbnail(percentage)); + } - Assert.Equal(320, image.Width); - Assert.Equal(240, image.Height); - } + [Fact] + public void ShouldThrowExceptionWhenPercentageWidthIsNegative() + { + var percentageWidth = new Percentage(-0.5); + var percentageHeight = new Percentage(10); + using var image = new MagickImage(); + Assert.Throws("percentageWidth", () => image.Thumbnail(percentageWidth, percentageHeight)); + } - [Fact] - public void ShouldResizeTheImageToTheCorrectDimensions() - { - var geometry = new MagickGeometry("1x1+0+0>"); - using var image = new MagickImage(Files.SnakewarePNG); - image.Thumbnail(geometry); + [Fact] + public void ShouldThrowExceptionWhenPercentageHeightIsNegative() + { + var percentageWidth = new Percentage(10); + var percentageHeight = new Percentage(-0.5); + using var image = new MagickImage(); + Assert.Throws("percentageHeight", () => image.Thumbnail(percentageWidth, percentageHeight)); + } + + [Fact] + public void ShouldCreateThumbnailOfTheImageWithTheSpecifiedPercentage() + { + using var image = new MagickImage(Files.Builtin.Logo); + image.Thumbnail(new Percentage(50)); - Assert.Equal(1, image.Width); - Assert.Equal(1, image.Height); + Assert.Equal(320, image.Width); + Assert.Equal(240, image.Height); + } } } }