Added extra unit tests

Author: egil

src/Core/AttributeComparison.cs

@@ -15,15 +15,15 @@ public AttributeComparison(in AttributeComparisonSource control, in AttributeCom
             Test = test;
         }
 
-        public (IElement ControlElement, IElement TestElement) GetNodesAsElements() 
+        public (IElement ControlElement, IElement TestElement) GetAttributeElements() 
             => ((IElement)Control.ElementSource.Node, (IElement)Test.ElementSource.Node);
 
         #region Equals and HashCode
         public bool Equals(AttributeComparison other) => Control == other.Control && Test == other.Test;
         public override bool Equals(object obj) => obj is AttributeComparison other && Equals(other);
         public override int GetHashCode() => (Control, Test).GetHashCode();
         public static bool operator ==(AttributeComparison left, AttributeComparison right) => left.Equals(right);
-        public static bool operator !=(AttributeComparison left, AttributeComparison right) => !(left == right);
+        public static bool operator !=(AttributeComparison left, AttributeComparison right) => !left.Equals(right);
         #endregion
     }
 }

src/Core/AttributeComparisonSource.cs

@@ -1,6 +1,7 @@
-using System;
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Extensions;
+using System;
 using System.Diagnostics.CodeAnalysis;
-using AngleSharp.Dom;
 
 namespace Egil.AngleSharp.Diffing.Core
 {
@@ -15,9 +16,11 @@ namespace Egil.AngleSharp.Diffing.Core
         public ComparisonSourceType SourceType { get; }
 
         [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
-        public AttributeComparisonSource(IAttr attribute, in ComparisonSource elementSource)
+        public AttributeComparisonSource(string attributeName, in ComparisonSource elementSource)
         {
-            if (attribute is null) throw new ArgumentNullException(nameof(attribute));
+            if (string.IsNullOrEmpty(attributeName)) throw new ArgumentNullException(nameof(attributeName));
+            if (!elementSource.Node.TryGetAttr(attributeName, out var attribute))
+                throw new ArgumentException("The comparison source does not contain an element or the specified attribute is missing on the element.", nameof(elementSource));
 
             Attribute = attribute;
             ElementSource = elementSource;
@@ -30,7 +33,7 @@ public AttributeComparisonSource(IAttr attribute, in ComparisonSource elementSou
         public override int GetHashCode() => (Attribute, ElementSource).GetHashCode();
         public override bool Equals(object obj) => obj is AttributeComparisonSource other && Equals(other);
         public static bool operator ==(AttributeComparisonSource left, AttributeComparisonSource right) => left.Equals(right);
-        public static bool operator !=(AttributeComparisonSource left, AttributeComparisonSource right) => !(left == right);
+        public static bool operator !=(AttributeComparisonSource left, AttributeComparisonSource right) => !left.Equals(right);
         #endregion
     }
 }

src/Core/CompareResult.cs

@@ -3,30 +3,22 @@
     public enum CompareResult
     {
         /// <summary>
-        /// Indicates the two compared nodes or attributes are the same.
+        /// Use when the two compared nodes or attributes are the same.
         /// </summary>
         Same,
         /// <summary>
-        /// Indicates the two compared nodes or attributes are the same AND no further comparison should happen on any child nodes or attributes.
-        /// </summary>
-        SameAndBreak,
-        /// <summary>
-        /// Indicates the two compared nodes or attributes are the different.
+        /// Use when the two compared nodes or attributes are the different.
         /// </summary>
         Different,
         /// <summary>
-        /// Indicates the two compared nodes or attributes are the different AND no further comparison should happen on any child nodes or attributes.
+        /// Use when the comparison should be skipped and any child-nodes or attributes skipped as well.
         /// </summary>
-        DifferentAndBreak
+        Skip
     }
 
     public static class CompareResultExtensions
     {
-        public static bool IsSame(this CompareResult compareResult) => compareResult == CompareResult.Same;
-        public static bool IsSameAndBreak(this CompareResult compareResult) => compareResult == CompareResult.SameAndBreak;
-        public static bool IsDifferent(this CompareResult compareResult) => compareResult == CompareResult.Different;
-        public static bool IsDifferentAndBreak(this CompareResult compareResult) => compareResult == CompareResult.DifferentAndBreak;
-        public static bool IsDecisionFinal(this CompareResult compareResult) => !compareResult.IsDifferent();
+        public static bool IsSameOrSkip(this CompareResult compareResult) => compareResult == CompareResult.Same || compareResult == CompareResult.Skip;
     }
 }
 

src/Core/Comparison.cs

@@ -41,11 +41,11 @@ public bool TryGetNodesAsType<TNode>([NotNullWhen(true)]out TNode? controlNode,
         }
 
         #region Equals and HashCode
-        public bool Equals(Comparison other) => Control == other.Control && Test == other.Test;
+        public bool Equals(Comparison other) => Control.Equals(other.Control) && Test.Equals(other.Test);
         public override bool Equals(object obj) => obj is Comparison other && Equals(other);
         public override int GetHashCode() => (Control, Test).GetHashCode();
         public static bool operator ==(Comparison left, Comparison right) => left.Equals(right);
-        public static bool operator !=(Comparison left, Comparison right) => !(left == right);
+        public static bool operator !=(Comparison left, Comparison right) => !left.Equals(right);
         #endregion
     }
 }

src/Core/ComparisonSource.cs

@@ -68,11 +68,11 @@ private static string CalculateNodePath(INode node, int index)
         }
 
         #region Equals and HashCode
-        public bool Equals(ComparisonSource other) => Node.Equals(other.Node) && Index == other.Index && Path.Equals(other.Path, StringComparison.Ordinal) && SourceType == other.SourceType;
+        public bool Equals(ComparisonSource other) => Node == other.Node && Index == other.Index && Path.Equals(other.Path, StringComparison.Ordinal) && SourceType == other.SourceType;
         public override int GetHashCode() => _hashCode;
         public override bool Equals(object obj) => obj is ComparisonSource other && Equals(other);
         public static bool operator ==(ComparisonSource left, ComparisonSource right) => left.Equals(right);
-        public static bool operator !=(ComparisonSource left, ComparisonSource right) => !(left == right);
+        public static bool operator !=(ComparisonSource left, ComparisonSource right) => !left.Equals(right);
         #endregion
     }
 }

src/Core/HtmlDifferenceEngine.cs

@@ -101,7 +101,7 @@ private IEnumerable<IDiff> CompareNode(DiffContext context, in Comparison compar
             }
 
             var compareRes = _compareStrategy.Compare(comparison);
-            if (compareRes == CompareResult.Different || compareRes == CompareResult.DifferentAndBreak)
+            if (compareRes == CompareResult.Different)
             {
                 IDiff diff = new Diff(comparison);
                 return new[] { diff };
@@ -115,12 +115,12 @@ private IEnumerable<IDiff> CompareElement(DiffContext context, in Comparison com
             var result = new List<IDiff>();
 
             var compareRes = _compareStrategy.Compare(comparison);
-            if (compareRes == CompareResult.Different || compareRes == CompareResult.DifferentAndBreak)
+            if (compareRes == CompareResult.Different)
             {
                 result.Add(new Diff(comparison));
             }
 
-            if (compareRes == CompareResult.Same || compareRes == CompareResult.Different)
+            if (compareRes != CompareResult.Skip)
             {
                 result.AddRange(CompareElementAttributes(context, comparison));
                 result.AddRange(CompareChildNodes(context, comparison));
@@ -198,7 +198,7 @@ private IEnumerable<IDiff> CompareAttributes(IEnumerable<AttributeComparison> co
             foreach (var comparison in comparisons)
             {
                 var compareRes = _compareStrategy.Compare(comparison);
-                if (compareRes == CompareResult.Different || compareRes == CompareResult.DifferentAndBreak)
+                if (compareRes == CompareResult.Different)
                     yield return new AttrDiff(comparison);
             }
         }

src/Core/SourceMap.cs

@@ -35,7 +35,7 @@ public SourceMap(in ComparisonSource elementSource)
                 SourceType = elementSource.SourceType;
                 foreach (var attr in element.Attributes)
                 {
-                    _sources.Add(attr.Name, new AttributeComparisonSource(attr, elementSource));
+                    _sources.Add(attr.Name, new AttributeComparisonSource(attr.Name, elementSource));
                 }
             }
             else

src/DiffBuilder.cs

@@ -36,6 +36,7 @@ public DiffBuilder WithFilter(FilterStrategy<ComparisonSource> filterStrategy)
 
         public DiffBuilder WithFilter(FilterStrategy<AttributeComparisonSource> filterStrategy)
         {
+        
             return this;
         }
 

src/DiffingStrategyPipeline.cs

@@ -45,10 +45,8 @@ public IEnumerable<AttributeComparison> Match(DiffContext context, SourceMap con
             }
         }
 
-        public CompareResult Compare(in Comparison comparison)
-            => Compare(comparison, _nodeComparers, CompareResult.DifferentAndBreak);
-        public CompareResult Compare(in AttributeComparison comparison)
-            => Compare(comparison, _attrComparers, CompareResult.Different);
+        public CompareResult Compare(in Comparison comparison) => Compare(comparison, _nodeComparers, CompareResult.Different);
+        public CompareResult Compare(in AttributeComparison comparison) => Compare(comparison, _attrComparers, CompareResult.Different);
 
         /// <summary>
         /// Adds a node filter to the pipeline.

src/Extensions/NodeExtensions.cs

@@ -11,6 +11,20 @@ public static bool HasAttributes(this INode node)
             return node is IElement element && element.Attributes.Length > 0;
         }
 
+        public static bool TryGetAttr(this INode node, string attributeName, [NotNullWhen(true)]out IAttr? attribute)
+        {
+            if (node is IElement element && element.HasAttribute(attributeName))
+            {
+                attribute = element.Attributes[attributeName];
+                return true;
+            }
+            else
+            {
+                attribute = default;
+                return false;
+            }
+        }
+
         public static bool TryGetAttrValue(this INode node, string attributeName, out bool result)
         {
 #pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.