tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Changes unit tests to use FluentAssertions and tests a bunch more stuff 

Former-commit-id: 237c6ce8e70f16f4154bd8d2b9d4379524d19cd7
Former-commit-id: f687f45da3e081dae7f1cfc15260d4a2c79319cb
af/merge-core
Thomas Broust 12 years ago
parent
5627d18fea
commit
1cfacd9612
3 changed files with 109 additions and 110 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 210
      src/ImageProcessor.UnitTests/ImageFactoryUnitTests.cs
  2. 8
      src/ImageProcessor.UnitTests/ImageProcessor.UnitTests.csproj
  3. 1
      src/ImageProcessor.UnitTests/packages.config

210
src/ImageProcessor.UnitTests/ImageFactoryUnitTests.cs
View File

@ -17,6 +17,7 @@ namespace ImageProcessor.UnitTests
using ImageProcessor.Imaging.Filters.EdgeDetection;
using ImageProcessor.Imaging.Filters.Photo;
using FluentAssertions;
using NUnit.Framework;
/// <summary>
@ -46,8 +47,9 @@ namespace ImageProcessor.UnitTests
using (ImageFactory imageFactory = new ImageFactory())
{
imageFactory.Load(file.FullName);
Assert.AreEqual(file.FullName, imageFactory.ImagePath);
Assert.IsNotNull(imageFactory.Image);
imageFactory.ImagePath.Should().Be(file.FullName, "because the path should have been memorized");
imageFactory.Image.Should().NotBeNull("because the image should have been loaded");
}
}
}
@ -67,8 +69,9 @@ namespace ImageProcessor.UnitTests
using (ImageFactory imageFactory = new ImageFactory())
{
imageFactory.Load(inStream);
Assert.AreEqual(null, imageFactory.ImagePath);
Assert.IsNotNull(imageFactory.Image);
imageFactory.ImagePath.Should().BeNull("because an image loaded from stream should not have a file path");
imageFactory.Image.Should().NotBeNull("because the image should have been loaded");
}
}
}
@ -87,7 +90,10 @@ namespace ImageProcessor.UnitTests
{
imageFactory.Load(file.FullName);
imageFactory.Save(outputFileName);
Assert.AreEqual(true, File.Exists(outputFileName));
File.Exists(outputFileName).Should().BeTrue("because the file should have been saved on disk");
File.Delete(outputFileName);
}
}
}
@ -104,7 +110,8 @@ namespace ImageProcessor.UnitTests
{
imageFactory.Save(s);
s.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(true, s.Capacity > 0);
s.Capacity.Should().BeGreaterThan(0, "because the stream should contain the image");
}
}
}
@ -118,9 +125,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Alpha(50);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the alpha operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -133,9 +139,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Brightness(50);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the brightness operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -148,9 +153,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.BackgroundColor(Color.Yellow);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the background color operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -163,9 +167,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Contrast(50);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the contrast operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -178,9 +181,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Saturation(50);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the saturation operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -193,9 +195,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Tint(Color.FromKnownColor(KnownColor.AliceBlue));
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the tint operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -208,9 +209,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Vignette(Color.FromKnownColor(KnownColor.AliceBlue));
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the vignette operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -223,7 +223,6 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Watermark(new TextLayer
{
FontFamily = new FontFamily("Arial"),
@ -231,7 +230,7 @@ namespace ImageProcessor.UnitTests
Position = new Point(10, 10),
Text = "Lorem ipsum dolor"
});
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the watermark operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -244,9 +243,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.GaussianBlur(5);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the blur operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -259,9 +257,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.GaussianBlur(new GaussianLayer { Sigma = 10, Size = 5, Threshold = 2 });
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the layered blur operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -274,9 +271,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.GaussianSharpen(5);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the sharpen operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -289,9 +285,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.GaussianSharpen(new GaussianLayer { Sigma = 10, Size = 5, Threshold = 2 });
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the layered sharpen operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -304,57 +299,56 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Filter(MatrixFilters.BlackWhite);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the bw filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.Comic);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the comic filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.Gotham);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the gotham filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.GreyScale);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the greyscale filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.HiSatch);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the hisatch operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.Invert);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the invert filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.Lomograph);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the lomo filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.LoSatch);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the losatch filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.Polaroid);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the polaroid filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Filter(MatrixFilters.Sepia);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the sepia filter operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
}
}
@ -367,9 +361,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.RoundedCorners(new RoundedCornerLayer(5));
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the rounded corners operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -383,8 +376,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
imageFactory.Constrain(new Size(MaxSize, MaxSize));
Assert.LessOrEqual(imageFactory.Image.Width, MaxSize);
Assert.LessOrEqual(imageFactory.Image.Height, MaxSize);
imageFactory.Image.Width.Should().BeLessOrEqualTo(MaxSize, "because the image size should have been reduced");
imageFactory.Image.Height.Should().BeLessOrEqualTo(MaxSize, "because the image size should have been reduced");
}
}
@ -398,11 +391,11 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Crop(new Rectangle(0, 0, MaxSize, MaxSize));
AssertImagesAreDifferent(original, imageFactory.Image);
Assert.AreEqual(MaxSize, imageFactory.Image.Width);
Assert.LessOrEqual(MaxSize, imageFactory.Image.Height);
AssertImagesAreDifferent(original, imageFactory.Image, "because the crop operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Image.Width.Should().Be(MaxSize, "because the cropped image should be {0}x{0}", MaxSize);
imageFactory.Image.Height.Should().Be(MaxSize, "because the cropped image should be {0}x{0}", MaxSize);
}
}
@ -416,11 +409,11 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Crop(new CropLayer(0, 0, MaxSize, MaxSize, CropMode.Pixels));
AssertImagesAreDifferent(original, imageFactory.Image);
Assert.AreEqual(MaxSize, imageFactory.Image.Width);
Assert.LessOrEqual(MaxSize, imageFactory.Image.Height);
AssertImagesAreDifferent(original, imageFactory.Image, "because the layered crop operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Image.Width.Should().Be(MaxSize, "because the cropped image should be {0}x{0}", MaxSize);
imageFactory.Image.Height.Should().Be(MaxSize, "because the cropped image should be {0}x{0}", MaxSize);
}
}
@ -433,18 +426,17 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Flip(true);
AssertImagesAreDifferent(original, imageFactory.Image);
Assert.AreEqual(original.Width, imageFactory.Image.Width);
Assert.AreEqual(original.Height, imageFactory.Image.Height);
AssertImagesAreDifferent(original, imageFactory.Image, "because the vertical flip operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Image.Width.Should().Be(original.Width, "because the dimensions should not have changed");
imageFactory.Image.Height.Should().Be(original.Height, "because the dimensions should not have changed");
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Flip();
AssertImagesAreDifferent(original, imageFactory.Image);
Assert.AreEqual(original.Width, imageFactory.Image.Width);
Assert.AreEqual(original.Height, imageFactory.Image.Height);
AssertImagesAreDifferent(original, imageFactory.Image, "because the horizontal flip operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Image.Width.Should().Be(original.Width, "because the dimensions should not have changed");
imageFactory.Image.Height.Should().Be(original.Height, "because the dimensions should not have changed");
}
}
@ -458,8 +450,9 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
imageFactory.Resize(new Size(NewSize, NewSize));
Assert.AreEqual(NewSize, imageFactory.Image.Width);
Assert.AreEqual(NewSize, imageFactory.Image.Height);
imageFactory.Image.Width.Should().Be(NewSize, "because the new image's size should be {0}x{0}", NewSize);
imageFactory.Image.Height.Should().Be(NewSize, "because the new image's size should be {0}x{0}", NewSize);
}
}
@ -473,8 +466,9 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
imageFactory.Resize(new ResizeLayer(new Size(NewSize, NewSize), ResizeMode.Stretch, AnchorPosition.Left));
Assert.AreEqual(NewSize, imageFactory.Image.Width);
Assert.AreEqual(NewSize, imageFactory.Image.Height);
imageFactory.Image.Width.Should().Be(NewSize, "because the new image's size should be {0}x{0}", NewSize);
imageFactory.Image.Height.Should().Be(NewSize, "because the new image's size should be {0}x{0}", NewSize);
}
}
@ -487,10 +481,10 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Rotate(90);
Assert.AreEqual(original.Height, imageFactory.Image.Width);
Assert.AreEqual(original.Width, imageFactory.Image.Height);
imageFactory.Image.Width.Should().Be(original.Height, "because the rotated image dimensions should have been switched");
imageFactory.Image.Height.Should().Be(original.Width, "because the rotated image dimensions should have been switched");
}
}
@ -503,15 +497,14 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Hue(90);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the hue operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.Hue(116, true);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the hue+rotate operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -524,9 +517,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.Pixelate(8);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the pixelate operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -542,7 +534,7 @@ namespace ImageProcessor.UnitTests
imageFactory.Quality(69);
int updated = imageFactory.CurrentImageFormat.Quality;
Assert.AreNotEqual(original, updated);
updated.Should().NotBe(original, "because the quality should have been changed");
}
}
@ -555,9 +547,8 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.ReplaceColor(Color.White, Color.Black, 90);
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the color replace operation should have been applied on {0}", imageFactory.ImagePath);
}
}
@ -570,52 +561,51 @@ namespace ImageProcessor.UnitTests
foreach (ImageFactory imageFactory in this.ListInputImages())
{
Image original = (Image)imageFactory.Image.Clone();
AssertImagesAreIdentical(original, imageFactory.Image);
imageFactory.DetectEdges(new KayyaliEdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the kayyali edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new KirschEdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the kirsch edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new Laplacian3X3EdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the laplacian 3x3 edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new Laplacian5X5EdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the laplacian 5x5 edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new LaplacianOfGaussianEdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the laplacian gaussian edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new PrewittEdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the prewitt edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new RobertsCrossEdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the roberts edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new ScharrEdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the scharr edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
imageFactory.DetectEdges(new SobelEdgeFilter());
AssertImagesAreDifferent(original, imageFactory.Image);
AssertImagesAreDifferent(original, imageFactory.Image, "because the sobel edge operation should have been applied on {0}", imageFactory.ImagePath);
imageFactory.Reset();
AssertImagesAreIdentical(original, imageFactory.Image);
AssertImagesAreIdentical(original, imageFactory.Image, "because the image should be reset");
}
}
@ -686,9 +676,9 @@ namespace ImageProcessor.UnitTests
/// </summary>
/// <param name="expected">The expected result</param>
/// <param name="tested">The tested image</param>
private void AssertImagesAreIdentical(Image expected, Image tested)
private void AssertImagesAreIdentical(Image expected, Image tested, string because, params string[] becauseArgs)
{
Assert.IsTrue(ToByteArray(expected).SequenceEqual(ToByteArray(tested)));
ToByteArray(expected).SequenceEqual(ToByteArray(tested)).Should().BeTrue(because, becauseArgs);
}
/// <summary>
@ -696,9 +686,9 @@ namespace ImageProcessor.UnitTests
/// </summary>
/// <param name="expected">The not-expected result</param>
/// <param name="tested">The tested image</param>
private void AssertImagesAreDifferent(Image expected, Image tested)
private void AssertImagesAreDifferent(Image expected, Image tested, string because, params string[] becauseArgs)
{
Assert.IsFalse(ToByteArray(expected).SequenceEqual(ToByteArray(tested)));
ToByteArray(expected).SequenceEqual(ToByteArray(tested)).Should().BeFalse(because, becauseArgs);
}
/// <summary>

8
src/ImageProcessor.UnitTests/ImageProcessor.UnitTests.csproj
View File

@ -37,6 +37,12 @@
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<ItemGroup>
<Reference Include="FluentAssertions">
<HintPath>..\packages\FluentAssertions.3.2.1\lib\net45\FluentAssertions.dll</HintPath>
</Reference>
<Reference Include="FluentAssertions.Core">
<HintPath>..\packages\FluentAssertions.3.2.1\lib\net45\FluentAssertions.Core.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Drawing" />
<Reference Include="nunit.framework">
@ -44,6 +50,8 @@
</Reference>
<Reference Include="System.Core" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Xml" />
<Reference Include="System.Xml.Linq" />
</ItemGroup>
<ItemGroup>
<Compile Include="ImageFactoryUnitTests.cs">

1
src/ImageProcessor.UnitTests/packages.config
View File

@ -1,4 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="FluentAssertions" version="3.2.1" targetFramework="net45" />
<package id="NUnit" version="2.6.3" targetFramework="net451" />
</packages>
Write Preview
Loading…
Cancel
Save