fix: improved tests by adding CompareResult.Unknown to use as initial option

egil · egil · commit 1c051995289a · 2021-09-11T12:41:58.000+02:00
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeComparerTest.cs
@@ -27,7 +27,7 @@ public void Test002()
             var comparison = ToAttributeComparison(@"<b foo>", "foo",
                                                     "<b foo>", "foo");
 
-            AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         [Fact(DisplayName = "When two attributes does not have the same name, the compare result is Different")]
@@ -36,7 +36,7 @@ public void Test003()
             var comparison = ToAttributeComparison(@"<b foo>", "foo",
                                                     "<b bar>", "bar");
 
-            AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
 
         [Fact(DisplayName = "When two attribute values are the same, the compare result is Same")]
@@ -45,7 +45,7 @@ public void Test004()
             var comparison = ToAttributeComparison(@"<b foo=""bar"">", "foo",
                                                    @"<b foo=""bar"">", "foo");
 
-            AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         [Fact(DisplayName = "When two attribute values are different, the compare result is Different")]
@@ -54,7 +54,7 @@ public void Test005()
             var comparison = ToAttributeComparison(@"<b foo=""bar"">", "foo",
                                                    @"<b foo=""baz"">", "foo");
 
-            AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
 
         [Fact(DisplayName = "When the control attribute is postfixed with :ignoreCase, " +
@@ -64,7 +64,7 @@ public void Test006()
             var comparison = ToAttributeComparison(@"<b foo:ignoreCase=""BAR"">", "foo:ignorecase",
                                                    @"<b foo=""bar"">", "foo");
 
-            AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         [Fact(DisplayName = "When the control attribute is postfixed with :regex, " +
@@ -75,7 +75,7 @@ public void Test007()
             var comparison = ToAttributeComparison(@"<b foo:regex=""foobar-\d{4}"">", "foo:regex",
                                                    @"<b foo=""foobar-2000"">", "foo");
 
-            AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         [Theory(DisplayName = "When the control attribute is postfixed with :regex:ignoreCase " +
@@ -90,7 +90,7 @@ public void Test008(string attrNamePostfix)
             var comparison = ToAttributeComparison($@"<b {controlAttrName}=""foobar-\d{{4}}"">", controlAttrName,
                                                    @"<b foo=""FOOBAR-2000"">", "foo");
 
-            AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/BooleanAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/BooleanAttributeComparerTest.cs
@@ -23,7 +23,7 @@ public void Test001()
             var sut = new BooleanAttributeComparer(BooleanAttributeComparision.Strict);
             var comparison = ToAttributeComparison("<b foo>", "foo", "<b bar>", "bar");
 
-            sut.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            sut.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
 
         [Fact(DisplayName = "When attribute name is not an boolean attribute, its current result is returned")]
@@ -49,12 +49,12 @@ public void Test003(string attrName)
             var c5 = ToAttributeComparison($@"<b {attrName}="""">", attrName, $@"<b {attrName}>", attrName);
             var c6 = ToAttributeComparison($@"<b {attrName}=""{attrName}"">", attrName, $@"<b {attrName}>", attrName);
 
-            sut.Compare(c1, CompareResult.Different).ShouldBe(CompareResult.Same);
-            sut.Compare(c2, CompareResult.Different).ShouldBe(CompareResult.Same);
-            sut.Compare(c3, CompareResult.Different).ShouldBe(CompareResult.Same);
-            sut.Compare(c4, CompareResult.Different).ShouldBe(CompareResult.Same);
-            sut.Compare(c5, CompareResult.Different).ShouldBe(CompareResult.Same);
-            sut.Compare(c6, CompareResult.Different).ShouldBe(CompareResult.Same);
+            sut.Compare(c1, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+            sut.Compare(c2, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+            sut.Compare(c3, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+            sut.Compare(c4, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+            sut.Compare(c5, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+            sut.Compare(c6, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         [Theory(DisplayName = "When attributes is boolean and mode is loose, the presence of " +
@@ -68,9 +68,9 @@ public void Test004(string attrName)
             var c3 = ToAttributeComparison($@"<b {attrName}=""true"">", attrName, $@"<b {attrName}=""false"">", attrName);
 
 
-            sut.Compare(c1, CompareResult.Different).ShouldBe(CompareResult.Same);
-            sut.Compare(c2, CompareResult.Different).ShouldBe(CompareResult.Same);
-            sut.Compare(c3, CompareResult.Different).ShouldBe(CompareResult.Same);
+            sut.Compare(c1, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+            sut.Compare(c2, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+            sut.Compare(c3, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/ClassAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/ClassAttributeComparerTest.cs
@@ -24,7 +24,7 @@ public void Test009(string controlClasses, string testClasses)
             var comparison = ToAttributeComparison($@"<p class=""{controlClasses}"">", "class",
                                                    $@"<p class=""{testClasses}"">", "class");
 
-            ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         [Fact(DisplayName = "When a class attribute is matched up with another attribute, the result is different")]
@@ -33,7 +33,7 @@ public void Test010()
             var comparison = ToAttributeComparison(@"<p class=""foo"">", "class",
                                                    @"<p bar=""bar"">", "bar");
 
-            ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
 
         [Theory(DisplayName = "When there are different number of classes in the class attributes the result is different")]
@@ -44,7 +44,7 @@ public void Test011(string controlClasses, string testClasses)
             var comparison = ToAttributeComparison($@"<p class=""{controlClasses}"">", "class",
                                                    $@"<p class=""{testClasses}"">", "class");
 
-            ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
 
         [Theory(DisplayName = "When the classes in the class attributes are different the result is different")]
@@ -57,7 +57,7 @@ public void Test012(string controlClasses, string testClasses)
             var comparison = ToAttributeComparison($@"<p class=""{controlClasses}"">", "class",
                                                    $@"<p class=""{testClasses}"">", "class");
 
-            ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreAttributeComparerTest.cs
@@ -33,7 +33,7 @@ public void Test004()
                 @"<p foo=""baz""></p>", "foo"
             );
 
-            IgnoreAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            IgnoreAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/StyleAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/StyleAttributeComparerTest.cs
@@ -1,7 +1,5 @@
 ﻿using AngleSharp.Diffing.Core;
-
 using Shouldly;
-
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
@@ -21,18 +19,31 @@ public void Test001()
             StyleAttributeComparer.Compare(comparison, CompareResult.Skip).ShouldBe(CompareResult.Skip);
         }
 
-        [Fact(DisplayName = "When style attributes has different values then Different is returned")]
-        public void Test002()
+        [Theory(DisplayName = "When style attributes has different values then Different is returned")]
+        [InlineData(@"<p style=""color: red"">", @"<p style=""color: black"">")]
+        [InlineData(@"<p style=""color: red"">", @"<p style=""text-align:center"">")]
+        [InlineData(@"<p style=""color: red"">", @"<p style=""color: red;text-align:center"">")]
+        [InlineData(@"<p style=""color: red;text-align:center"">", @"<p style=""color: red"">")]
+        public void Test002(string control, string test)
         {
-            var comparison = ToAttributeComparison(@"<p style=""color: red"">", "style", @"<p style=""color: black"">", "style");
-            StyleAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            var comparison = ToAttributeComparison(control, "style", test, "style");
+            StyleAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
 
         [Fact(DisplayName = "Comparer should correctly ignore insignificant whitespace")]
         public void Test003()
         {
             var comparison = ToAttributeComparison(@"<p style=""color: red"">", "style", @"<p style=""color:red"">", "style");
-            StyleAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            StyleAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
+        }
+
+        [Theory(DisplayName = "Comparer should ignore trailing semi colons")]
+        [InlineData(@"<p style=""color:red;"">", @"<p style=""color:red"">")]
+        [InlineData(@"<p style=""color:red"">", @"<p style=""color:red;"">")]
+        public void Test004(string control, string test)
+        {
+            var comparison = ToAttributeComparison(control, "style", test, "style");
+            StyleAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreAttributesElementComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreAttributesElementComparerTest.cs
@@ -37,8 +37,8 @@ public void Test002(string controlHtml)
         {
             var comparison = ToComparison(controlHtml, "<p></p>");
 
-            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Same | CompareResult.SkipAttributes);
-            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different | CompareResult.SkipAttributes);
+            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.SkipAttributes);
+            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.SkipAttributes);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreChildrenElementComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreChildrenElementComparerTest.cs
@@ -37,8 +37,8 @@ public void Test002(string controlHtml)
         {
             var comparison = ToComparison(controlHtml, "<p></p>");
 
-            IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Same | CompareResult.SkipChildren);
-            IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different | CompareResult.SkipChildren);
+            IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.SkipChildren);
+            IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.SkipChildren);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreElementComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreElementComparerTest.cs
@@ -35,8 +35,8 @@ public void Test002(string controlHtml)
         {
             var comparison = ToComparison(controlHtml, "<p></p>");
 
-            IgnoreElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Skip);
-            IgnoreElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Skip);
+            IgnoreElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Skip);
+            IgnoreElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Skip);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/NodeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/NodeComparerTest.cs
@@ -17,7 +17,7 @@ public NodeComparerTest(DiffingTestFixture fixture) : base(fixture)
         public void Test001()
         {
             var comparison = ToComparison("<p>", "<p>");
-            ElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            ElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         [Theory(DisplayName = "When control and test nodes have the a different type and name, the result is Different")]
@@ -28,7 +28,7 @@ public void Test001()
         public void Test002(string controlHtml, string testHtml)
         {
             var comparison = ToComparison(controlHtml, testHtml);
-            ElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            ElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/StyleSheetTextNodeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/StyleSheetTextNodeComparerTest.cs
@@ -33,12 +33,12 @@ public void Test0001()
         }
 
 
-        [Fact(DisplayName = "The comparer responses with Different when style information is different")]
+        [Fact(DisplayName = "The comparer responds with Different when style information is different")]
         public void Test001()
         {
             var comparison = ToStyleComparison(@"h1{background:#000;}", @"h1{color:#000;}");
 
-            StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);
         }
 
         [Theory(DisplayName = "The comparer ignores insignificant whitespace")]
@@ -51,7 +51,7 @@ public void Test003(string whitespace)
         {
             var comparison = ToStyleComparison($@"h1{whitespace}{{{whitespace}color:{whitespace}#000;{whitespace}}}", @"h1{color:#000;}");
 
-            StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);
         }
 
         private Comparison ToStyleComparison(string controlStyleText, string testStyleText)
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeComparerTest.cs
diff --git a/src/AngleSharp.Diffing/Core/CompareResult.cs b/src/AngleSharp.Diffing/Core/CompareResult.cs
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/ClassAttributeComparer.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/ClassAttributeComparer.cs
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreAttributesElementComparer.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreAttributesElementComparer.cs
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreChildrenElementComparer.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreChildrenElementComparer.cs

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public void Test002()`
`27`	`27`	`var comparison = ToAttributeComparison(@"<b foo>", "foo",`
`28`	`28`	`"<b foo>", "foo");`
`29`	`29`
`30`		`- AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`30`	`+ AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`[Fact(DisplayName = "When two attributes does not have the same name, the compare result is Different")]`
`@@ -36,7 +36,7 @@ public void Test003()`
`36`	`36`	`var comparison = ToAttributeComparison(@"<b foo>", "foo",`
`37`	`37`	`"<b bar>", "bar");`
`38`	`38`
`39`		`- AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);`
	`39`	`+ AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`[Fact(DisplayName = "When two attribute values are the same, the compare result is Same")]`
`@@ -45,7 +45,7 @@ public void Test004()`
`45`	`45`	`var comparison = ToAttributeComparison(@"<b foo=""bar"">", "foo",`
`46`	`46`	`@"<b foo=""bar"">", "foo");`
`47`	`47`
`48`		`- AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`48`	`+ AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`[Fact(DisplayName = "When two attribute values are different, the compare result is Different")]`
`@@ -54,7 +54,7 @@ public void Test005()`
`54`	`54`	`var comparison = ToAttributeComparison(@"<b foo=""bar"">", "foo",`
`55`	`55`	`@"<b foo=""baz"">", "foo");`
`56`	`56`
`57`		`- AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);`
	`57`	`+ AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`[Fact(DisplayName = "When the control attribute is postfixed with :ignoreCase, " +`
`@@ -64,7 +64,7 @@ public void Test006()`
`64`	`64`	`var comparison = ToAttributeComparison(@"<b foo:ignoreCase=""BAR"">", "foo:ignorecase",`
`65`	`65`	`@"<b foo=""bar"">", "foo");`
`66`	`66`
`67`		`- AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`67`	`+ AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`[Fact(DisplayName = "When the control attribute is postfixed with :regex, " +`
`@@ -75,7 +75,7 @@ public void Test007()`
`75`	`75`	`var comparison = ToAttributeComparison(@"<b foo:regex=""foobar-\d{4}"">", "foo:regex",`
`76`	`76`	`@"<b foo=""foobar-2000"">", "foo");`
`77`	`77`
`78`		`- AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`78`	`+ AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`[Theory(DisplayName = "When the control attribute is postfixed with :regex:ignoreCase " +`
`@@ -90,7 +90,7 @@ public void Test008(string attrNamePostfix)`
`90`	`90`	`var comparison = ToAttributeComparison($@"<b {controlAttrName}=""foobar-\d{{4}}"">", controlAttrName,`
`91`	`91`	`@"<b foo=""FOOBAR-2000"">", "foo");`
`92`	`92`
`93`		`- AttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`93`	`+ AttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public void Test009(string controlClasses, string testClasses)`
`24`	`24`	`var comparison = ToAttributeComparison($@"<p class=""{controlClasses}"">", "class",`
`25`	`25`	`$@"<p class=""{testClasses}"">", "class");`
`26`	`26`
`27`		`- ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`27`	`+ ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`[Fact(DisplayName = "When a class attribute is matched up with another attribute, the result is different")]`
`@@ -33,7 +33,7 @@ public void Test010()`
`33`	`33`	`var comparison = ToAttributeComparison(@"<p class=""foo"">", "class",`
`34`	`34`	`@"<p bar=""bar"">", "bar");`
`35`	`35`
`36`		`- ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);`
	`36`	`+ ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`[Theory(DisplayName = "When there are different number of classes in the class attributes the result is different")]`
`@@ -44,7 +44,7 @@ public void Test011(string controlClasses, string testClasses)`
`44`	`44`	`var comparison = ToAttributeComparison($@"<p class=""{controlClasses}"">", "class",`
`45`	`45`	`$@"<p class=""{testClasses}"">", "class");`
`46`	`46`
`47`		`- ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);`
	`47`	`+ ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`[Theory(DisplayName = "When the classes in the class attributes are different the result is different")]`
`@@ -57,7 +57,7 @@ public void Test012(string controlClasses, string testClasses)`
`57`	`57`	`var comparison = ToAttributeComparison($@"<p class=""{controlClasses}"">", "class",`
`58`	`58`	`$@"<p class=""{testClasses}"">", "class");`
`59`	`59`
`60`		`- ClassAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);`
	`60`	`+ ClassAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public void Test004()`
`33`	`33`	`@"<p foo=""baz""></p>", "foo"`
`34`	`34`	`);`
`35`	`35`
`36`		`- IgnoreAttributeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`36`	`+ IgnoreAttributeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,8 @@ public void Test002(string controlHtml)`
`37`	`37`	`{`
`38`	`38`	`var comparison = ToComparison(controlHtml, "<p></p>");`
`39`	`39`
`40`		`- IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Same \| CompareResult.SkipAttributes);`
`41`		`- IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different \| CompareResult.SkipAttributes);`
	`40`	`+ IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.SkipAttributes);`
	`41`	`+ IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.SkipAttributes);`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,8 @@ public void Test002(string controlHtml)`
`35`	`35`	`{`
`36`	`36`	`var comparison = ToComparison(controlHtml, "<p></p>");`
`37`	`37`
`38`		`- IgnoreElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Skip);`
`39`		`- IgnoreElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Skip);`
	`38`	`+ IgnoreElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Skip);`
	`39`	`+ IgnoreElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Skip);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public NodeComparerTest(DiffingTestFixture fixture) : base(fixture)`
`17`	`17`	`public void Test001()`
`18`	`18`	`{`
`19`	`19`	`var comparison = ToComparison("<p>", "<p>");`
`20`		`- ElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`20`	`+ ElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`[Theory(DisplayName = "When control and test nodes have the a different type and name, the result is Different")]`
`@@ -28,7 +28,7 @@ public void Test001()`
`28`	`28`	`public void Test002(string controlHtml, string testHtml)`
`29`	`29`	`{`
`30`	`30`	`var comparison = ToComparison(controlHtml, testHtml);`
`31`		`- ElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);`
	`31`	`+ ElementComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,12 +33,12 @@ public void Test0001()`
`33`	`33`	`}`
`34`	`34`
`35`	`35`
`36`		`- [Fact(DisplayName = "The comparer responses with Different when style information is different")]`
	`36`	`+ [Fact(DisplayName = "The comparer responds with Different when style information is different")]`
`37`	`37`	`public void Test001()`
`38`	`38`	`{`
`39`	`39`	`var comparison = ToStyleComparison(@"h1{background:#000;}", @"h1{color:#000;}");`
`40`	`40`
`41`		`- StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);`
	`41`	`+ StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Different);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`[Theory(DisplayName = "The comparer ignores insignificant whitespace")]`
`@@ -51,7 +51,7 @@ public void Test003(string whitespace)`
`51`	`51`	`{`
`52`	`52`	`var comparison = ToStyleComparison($@"h1{whitespace}{{{whitespace}color:{whitespace}#000;{whitespace}}}", @"h1{color:#000;}");`
`53`	`53`
`54`		`- StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);`
	`54`	`+ StyleSheetTextNodeComparer.Compare(comparison, CompareResult.Unknown).ShouldBe(CompareResult.Same);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`private Comparison ToStyleComparison(string controlStyleText, string testStyleText)`