diff --git a/README.md b/README.md
index 7caf2ce..e35b78b 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,8 @@ Default usage:
     var secondImage = new Bitmap("path/to/second/image);
 
     var comparer = new BitmapComparer();
-    var diff = comparer.Compare(firstImage, secondImage);
+    var diff = comparer.Compare(firstImage, secondImage); //Returns a result with the differences + the Bitmap
+    var generate = comparer.Generate(firstImage, secondImage);// Generates the bitmap image and returns a Bitmap
 
 When initialized without options, the following values are used:
 
@@ -36,19 +37,21 @@ When initialized without options, the following values are used:
 - BoundingBoxPadding: 2
 - BoundingBoxColor: Red
 - BoundingBoxMode: Single
+- BoundingBoxThickness: 1
 
 
 The compare object can be configured to use different settings for the different stages of processing.
 
     var options = new CompareOptions 
     {
-		AnalyzerType = AnalyzerTypes.CIE76,
+	AnalyzerType = AnalyzerTypes.CIE76,
         JustNoticableDifference = 2.3,
         DetectionPadding = 2,
         Labeler = LabelerTypes.ConnectedComponentLabeling,
         BoundingBoxColor = Color.Red,
         BoundingBoxPadding = 2,
-        BoundingBoxMode = BoundingBoxModes.Multiple
+        BoundingBoxMode = BoundingBoxModes.Multiple,
+        BoundingBoxThickness = 1 
     };
     var comparer = new BitmapComparer(options);
 
@@ -76,6 +79,10 @@ The color of the bounding box to be drawn when highlighting detected differences
 #### Bounding Box Padding
 The number of pixels of padding to include around the detected difference when drawing a bounding box.
 
+#### Bounding Box Thickness
+The thickness of the rectangle showing the difference in pixel. Default = 1
+
+
 #### Bounding Box Mode
 Specifies how to build the bounding boxes when highlighting the detected differences.
 
diff --git a/src/.vs/ImageDiff/v16/TestStore/0/009.testlog b/src/.vs/ImageDiff/v16/TestStore/0/009.testlog
new file mode 100644
index 0000000..6eedade
Binary files /dev/null and b/src/.vs/ImageDiff/v16/TestStore/0/009.testlog differ
diff --git a/src/.vs/ImageDiff/v16/TestStore/0/testlog.manifest b/src/.vs/ImageDiff/v16/TestStore/0/testlog.manifest
new file mode 100644
index 0000000..ce543b7
Binary files /dev/null and b/src/.vs/ImageDiff/v16/TestStore/0/testlog.manifest differ
diff --git a/src/ImageDiff/BitmapComparer.cs b/src/ImageDiff/BitmapComparer.cs
index 78619ba..6e9510c 100644
--- a/src/ImageDiff/BitmapComparer.cs
+++ b/src/ImageDiff/BitmapComparer.cs
@@ -15,6 +15,7 @@ public class BitmapComparer : IImageComparer<Bitmap>
         private int DetectionPadding { get; set; }
         private int BoundingBoxPadding { get; set; }
         private Color BoundingBoxColor { get; set; }
+        private int BoundingBoxThickness { get; set; }
         private BoundingBoxModes BoundingBoxMode { get; set; }
         private AnalyzerTypes AnalyzerType { get; set; }
 
@@ -47,21 +48,31 @@ private void Initialize(CompareOptions options)
             BoundingBoxPadding = options.BoundingBoxPadding;
             BoundingBoxMode = options.BoundingBoxMode;
             AnalyzerType = options.AnalyzerType;
+            BoundingBoxThickness = options.BoundingBoxThickness;
         }
 
-        public Bitmap Compare(Bitmap firstImage, Bitmap secondImage)
+
+
+        public Bitmap Generate(Bitmap firstImage, Bitmap secondImage)
+        {
+            Result result = Compare(firstImage, secondImage);
+            return result.Image;
+        }
+
+        public Result Compare(Bitmap firstImage, Bitmap secondImage)
         {
             if (firstImage == null) throw new ArgumentNullException("firstImage");
             if (secondImage == null) throw new ArgumentNullException("secondImage");
             if (firstImage.Width != secondImage.Width || firstImage.Height != secondImage.Height) throw new ArgumentException("Bitmaps must be the same size.");
-            
+
             var differenceMap = BitmapAnalyzer.Analyze(firstImage, secondImage);
             var differenceLabels = Labeler.Label(differenceMap);
             var boundingBoxes = BoundingBoxIdentifier.CreateBoundingBoxes(differenceLabels);
             var differenceBitmap = CreateImageWithBoundingBoxes(secondImage, boundingBoxes);
-            return differenceBitmap;
+            return Result.Create(differenceBitmap, boundingBoxes);
         }
 
+
         public bool Equals(Bitmap firstImage, Bitmap secondImage)
         {
             if (firstImage == null && secondImage == null) return true;
@@ -95,7 +106,8 @@ private Bitmap CreateImageWithBoundingBoxes(Bitmap secondImage, IEnumerable<Rect
 
             using (var g = Graphics.FromImage(differenceBitmap))
             {
-                var pen = new Pen(BoundingBoxColor);
+                var pen = new Pen(BoundingBoxColor,BoundingBoxThickness) ;
+                
                 foreach (var boundingRectangle in boundingRectangles)
                 {
                     g.DrawRectangle(pen, boundingRectangle);
diff --git a/src/ImageDiff/CompareOptions.cs b/src/ImageDiff/CompareOptions.cs
index df4cca0..06984e1 100644
--- a/src/ImageDiff/CompareOptions.cs
+++ b/src/ImageDiff/CompareOptions.cs
@@ -9,6 +9,7 @@ public class CompareOptions
         public double JustNoticeableDifference { get; set; }
         public int DetectionPadding { get; set; }
         public int BoundingBoxPadding { get; set; }
+        public int BoundingBoxThickness { get; set; }
         public Color BoundingBoxColor { get; set; }
         public BoundingBoxModes BoundingBoxMode { get; set; }
 
@@ -21,6 +22,7 @@ public CompareOptions()
             BoundingBoxColor = Color.Red;
             BoundingBoxMode = BoundingBoxModes.Single;
             AnalyzerType = AnalyzerTypes.ExactMatch;
+            BoundingBoxThickness = 1;
         }
     }
 }
\ No newline at end of file
diff --git a/src/ImageDiff/IImageComparer.cs b/src/ImageDiff/IImageComparer.cs
index f47cbc4..fa7e537 100644
--- a/src/ImageDiff/IImageComparer.cs
+++ b/src/ImageDiff/IImageComparer.cs
@@ -4,7 +4,8 @@ namespace ImageDiff
 {
     public interface IImageComparer<T> where T : Image
     {
-        T Compare(T firstImage, T secondImage);
+        T Generate(T firstImage, T secondImage);
+        Result Compare(T firstImage, T secondImage);
         bool Equals(T firstImage, T secondImage);
     }
 }
\ No newline at end of file
diff --git a/src/ImageDiff/ImageDiff.csproj b/src/ImageDiff/ImageDiff.csproj
index c984cd3..2688ca0 100644
--- a/src/ImageDiff/ImageDiff.csproj
+++ b/src/ImageDiff/ImageDiff.csproj
@@ -56,6 +56,7 @@
     <Compile Include="BoundingBoxes\MultipleBoundingBoxIdentifier.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="BoundingBoxes\SingleBoundingBoxIdentifer.cs" />
+    <Compile Include="ResultBitmap.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/src/ImageDiff/ResultBitmap.cs b/src/ImageDiff/ResultBitmap.cs
new file mode 100644
index 0000000..5c0f0e7
--- /dev/null
+++ b/src/ImageDiff/ResultBitmap.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ImageDiff
+{
+    public class Result
+    {
+
+        public static Result Create(Bitmap image, IEnumerable<Rectangle> boundingBoxes)
+        {
+            return new Result()
+            {
+                Image = image,
+                BoundingBoxes = boundingBoxes
+            };
+        }
+
+        public System.Drawing.Bitmap Image { get; set; }
+
+        public IEnumerable<Rectangle> BoundingBoxes{ get; set; }
+
+        public bool IsSimilar
+        {
+            get
+            {
+                return BoundingBoxes.Count() == 0;
+            }
+        }
+
+        /// <summary>
+        /// For more options, use Image.Save
+        /// </summary>
+        /// <param name="filename"></param>
+        public void Save(string filename)
+        {
+            Image.Save(filename);
+        }
+
+        public void Save(string filename, System.Drawing.Imaging.ImageFormat format)
+        {
+            Image.Save(filename, format);
+        }
+
+
+
+
+
+    }
+
+}
+
diff --git a/src/ImageDiffTests/Bitmap2ComparerTests.cs b/src/ImageDiffTests/Bitmap2ComparerTests.cs
new file mode 100644
index 0000000..6423b08
--- /dev/null
+++ b/src/ImageDiffTests/Bitmap2ComparerTests.cs
@@ -0,0 +1,264 @@
+using System;
+using System.Drawing;
+using ImageDiff;
+using NUnit.Framework;
+
+namespace ImageDiffTests
+{
+    [TestFixture]
+    public class Bitmap2ComparerTests
+    {
+        protected const string TestImage1 = "./images/TestImage2A.png";
+        protected const string TestImage2 = "./images/TestImage2B.png";
+        protected const string OutputFormat = "diff{0}.png";
+        protected Bitmap FirstImage { get; set; }
+        protected Bitmap SecondImage { get; set; }
+
+        [SetUp]
+        public void Setup()
+        {
+            FirstImage = new Bitmap(TestImage1);
+            SecondImage = new Bitmap(TestImage2);
+        }
+
+        [Test, ExpectedException(typeof(ArgumentNullException))]
+        public void CompareThrowsWhenFirstImageIsNull()
+        {
+            var target = new BitmapComparer(null);
+            target.Compare(null, SecondImage);
+        }
+
+        [Test, ExpectedException(typeof(ArgumentNullException))]
+        public void CompareThrowsWhenSecondImageIsNull()
+        {
+            var target = new BitmapComparer(null);
+            target.Compare(FirstImage, null);
+        }
+
+        [Test, ExpectedException(typeof(ArgumentException))]
+        public void CompareThrowsWhenImagesAreNotSameWidth()
+        {
+            var firstBitmap = new Bitmap(10, 10);
+            var secondBitmap = new Bitmap(20, 10);
+
+            var target = new BitmapComparer(null);
+            target.Compare(firstBitmap, secondBitmap);
+        }
+
+        [Test, ExpectedException(typeof(ArgumentException))]
+        public void CompareThrowsWhenImagesAreNotSameHeight()
+        {
+            var firstBitmap = new Bitmap(10, 10);
+            var secondBitmap = new Bitmap(10, 20);
+
+            var target = new BitmapComparer(null);
+            target.Compare(firstBitmap, secondBitmap);
+        }
+
+        [Test, ExpectedException(typeof(ArgumentException))]
+        public void ImageDiffThrowsWhenBoundingBoxPaddingIsLessThanZero()
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = BoundingBoxModes.Single,
+                AnalyzerType = AnalyzerTypes.ExactMatch,
+                DetectionPadding = 2,
+                BoundingBoxPadding = -2,
+                Labeler = LabelerTypes.Basic
+            });
+        }
+
+        [Test, ExpectedException(typeof(ArgumentException))]
+        public void ImageDiffThrowsWhenDetectionPaddingIsLessThanZero()
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = BoundingBoxModes.Single,
+                AnalyzerType = AnalyzerTypes.ExactMatch,
+                DetectionPadding = -2,
+                BoundingBoxPadding = 2,
+                Labeler = LabelerTypes.Basic
+            });
+        }
+
+        [Test]
+        public void CompareWorksWithNoOptions()
+        {
+            var target = new BitmapComparer();
+            var result = target.Compare(FirstImage, SecondImage);
+            result.Save(string.Format(OutputFormat, "CompareWorksWithNullOptions"), SecondImage.RawFormat);
+        }
+
+        [Test]
+        public void CompareWorksWithNullOptions()
+        {
+            var target = new BitmapComparer(null);
+            var result = target.Compare(FirstImage, SecondImage);
+            result.Save(string.Format(OutputFormat, "CompareWorksWithNullOptions"), SecondImage.RawFormat);
+        }
+
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.Basic, 1)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling, 1)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.Basic, 1)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling, 1)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.Basic, 1)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling, 1)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.Basic, 1)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling, 1)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling, 5)]
+        public void CompareWorksWithIdenticalImages(AnalyzerTypes aType, BoundingBoxModes bMode, LabelerTypes lType, int BoundingBoxThickness)
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                AnalyzerType = aType,
+                BoundingBoxMode = bMode,
+                Labeler = lType
+            });
+            var result = target.Compare(FirstImage, FirstImage);
+            result.Save(string.Format(OutputFormat, string.Format("CompareWorksWithIdenticalImages_{0}_{1}_{2}_3", aType, bMode, lType,BoundingBoxThickness)),
+                SecondImage.RawFormat); ;
+        }
+
+
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        public void CompareWorksWithDifferentImages(AnalyzerTypes aType, BoundingBoxModes bMode, LabelerTypes lType)
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = bMode,
+                AnalyzerType = aType,
+                DetectionPadding = 2,
+                BoundingBoxPadding = 2,
+                Labeler = lType
+            });
+            var result = target.Compare(FirstImage, SecondImage);
+            result.Save(string.Format(OutputFormat, string.Format("CompareWorksWithDifferentImages_{0}_{1}_{2}", aType, bMode, lType)), SecondImage.RawFormat);
+        }
+
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        public void EqualsReturnsTrueWithSameImage(AnalyzerTypes aType, BoundingBoxModes bMode, LabelerTypes lType)
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = bMode,
+                AnalyzerType = aType,
+                DetectionPadding = 2,
+                BoundingBoxPadding = 2,
+                Labeler = lType
+            });
+            var newInstanceOfFirstImage = new Bitmap(TestImage1);
+            var result = target.Equals(FirstImage, newInstanceOfFirstImage);
+            Assert.IsTrue(result);
+        }
+
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        public void EqualsReturnsFalseWithDifferentImage(AnalyzerTypes aType, BoundingBoxModes bMode, LabelerTypes lType)
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = bMode,
+                AnalyzerType = aType,
+                DetectionPadding = 2,
+                BoundingBoxPadding = 2,
+                Labeler = lType
+            });
+            var result = target.Equals(FirstImage, SecondImage);
+            Assert.IsFalse(result);
+        }
+
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        public void EqualsReturnsTrueWithNullImages(AnalyzerTypes aType, BoundingBoxModes bMode, LabelerTypes lType)
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = bMode,
+                AnalyzerType = aType,
+                DetectionPadding = 2,
+                BoundingBoxPadding = 2,
+                Labeler = lType
+            });
+            var result = target.Equals(null, null);
+            Assert.IsTrue(result);
+        }
+
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        public void EqualsReturnsFalseWithNullFirstImage(AnalyzerTypes aType, BoundingBoxModes bMode, LabelerTypes lType)
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = bMode,
+                AnalyzerType = aType,
+                DetectionPadding = 2,
+                BoundingBoxPadding = 2,
+                Labeler = lType
+            });
+            var result = target.Equals(null, SecondImage);
+            Assert.IsFalse(result);
+        }
+
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.CIE76, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Single, LabelerTypes.ConnectedComponentLabeling)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.Basic)]
+        [TestCase(AnalyzerTypes.ExactMatch, BoundingBoxModes.Multiple, LabelerTypes.ConnectedComponentLabeling)]
+        public void EqualsReturnsFalseWithNullSecondImage(AnalyzerTypes aType, BoundingBoxModes bMode, LabelerTypes lType)
+        {
+            var target = new BitmapComparer(new CompareOptions
+            {
+                BoundingBoxColor = Color.Red,
+                BoundingBoxMode = bMode,
+                AnalyzerType = aType,
+                DetectionPadding = 2,
+                BoundingBoxPadding = 2,
+                Labeler = lType
+            });
+            var result = target.Equals(FirstImage, null);
+            Assert.IsFalse(result);
+        }
+    }
+}
diff --git a/src/ImageDiffTests/ImageDiffTests.csproj b/src/ImageDiffTests/ImageDiffTests.csproj
index e65fc18..d62ad70 100644
--- a/src/ImageDiffTests/ImageDiffTests.csproj
+++ b/src/ImageDiffTests/ImageDiffTests.csproj
@@ -32,6 +32,12 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\MSTest.TestFramework.2.1.2\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\MSTest.TestFramework.2.1.2\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll</HintPath>
+    </Reference>
     <Reference Include="nunit.framework, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
@@ -42,6 +48,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AnalyerFactoryTests.cs" />
+    <Compile Include="Bitmap2ComparerTests.cs" />
     <Compile Include="BoundingBoxFactoryTests.cs" />
     <Compile Include="BitmapComparerTests.cs" />
     <Compile Include="LabelerFactoryTests.cs" />
@@ -66,6 +73,8 @@
     <Content Include="images\TestImage2.png">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>
+    <Content Include="images\TestImage2A.png" />
+    <Content Include="images\TestImage2B.png" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
diff --git a/src/ImageDiffTests/images/TestImage2A.png b/src/ImageDiffTests/images/TestImage2A.png
new file mode 100644
index 0000000..9d23065
Binary files /dev/null and b/src/ImageDiffTests/images/TestImage2A.png differ
diff --git a/src/ImageDiffTests/images/TestImage2B.png b/src/ImageDiffTests/images/TestImage2B.png
new file mode 100644
index 0000000..eaa7342
Binary files /dev/null and b/src/ImageDiffTests/images/TestImage2B.png differ
diff --git a/src/ImageDiffTests/packages.config b/src/ImageDiffTests/packages.config
index c714ef3..f0f414d 100644
--- a/src/ImageDiffTests/packages.config
+++ b/src/ImageDiffTests/packages.config
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="MSTest.TestFramework" version="2.1.2" targetFramework="net45" />
   <package id="NUnit" version="2.6.4" targetFramework="net45" />
 </packages>
\ No newline at end of file