port ElementSelectors.ByNameAndAllAttributes from Java version

Author: bodewig

README.md

@@ -222,3 +222,9 @@ assemblies. In order to run the tests use
 > dotnet test src/tests/net-constraints-nunit3/XMLUnit.NUnit3.Constraints.Test.csproj
 > dotnet test src/tests/net-placeholders/XMLUnit.Placeholders.Tests.csproj
 ```
+
+You may need to specify
+[`--roll-forward`](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet#rollforward)
+of
+[`DOTNET_ROLL_FORWARD`](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-environment-variables#dotnet_roll_forward)
+to run the tests when using recent versions of .NET.

RELEASE_NOTES.md

@@ -2,6 +2,10 @@
 
 ## XMLUnit.NET 2.9.3 - /not released, yet/
 
+* add a new `ElementSelectors.ByNameAndAllAttributes` variant that filters attributes before deciding whether elements can
+  be compared.
+  Inspired by Issue [#xmlunit/259](https://github.com/xmlunit/xmlunit/issues/259)
+
 * `Nodes.StripElementContentWhitespace` had the same problem of not
   knowning about `XmlWhitespace` that caused
   Issue [#38](https://github.com/xmlunit/xmlunit.net/issues/38)

src/main/net-core/Diff/ElementSelectors.cs

@@ -152,19 +152,31 @@ public static ElementSelector
         /// Elements with the same local name (and namespace URI - if any)
         /// and attribute values for all attributes can be compared.
         /// </summary>
+        /// <remarks>
+        ///   <para>
+        /// This ElementSelector doesn't know anything about a
+        /// potentially configured attribute filter so may also
+        /// compare attributes that are excluded from comparison by
+        /// the filter. Use the ByNameAndAllAttributes(Predicate)
+        /// passing in your attribute filter if this causes problems.
+        ///   </para>
+        /// </remarks>
         public static bool ByNameAndAllAttributes(XmlElement controlElement,
                                                   XmlElement testElement) {
-            if (!ByName(controlElement, testElement)) {
-                return false;
-            }
-            IDictionary<XmlQualifiedName, string> cAttrs =
-                Nodes.GetAttributes(controlElement);
-            IDictionary<XmlQualifiedName, string> tAttrs =
-                Nodes.GetAttributes(testElement);
-            if (cAttrs.Count != tAttrs.Count) {
-                return false;
-            }
-            return MapsEqualForKeys(cAttrs, tAttrs, cAttrs.Keys);
+            return ByNameAndAllAttributes(ignored => true, controlElement, testElement);
+        }
+
+        /// <summary>
+        /// Elements with the same local name (and namespace URI - if any)
+        /// and attribute values for all attributes can be compared.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        /// since XMLUnit 2.9.3
+        ///   </para>
+        /// </remarks>
+        public static ElementSelector ByNameAndAllAttributes(Predicate<XmlAttribute> attributeFiler) {
+            return (control, test) => ByNameAndAllAttributes(attributeFiler, control, test);
         }
 
         /// <summary>
@@ -420,5 +432,21 @@ private static bool
             });
         }
 
+        private static bool ByNameAndAllAttributes(Predicate<XmlAttribute> attributeFiler,
+                                                   XmlElement controlElement,
+                                                   XmlElement testElement) {
+            if (!ByName(controlElement, testElement)) {
+                return false;
+            }
+            IDictionary<XmlQualifiedName, string> cAttrs =
+                Nodes.GetAttributes(controlElement, attributeFiler);
+            IDictionary<XmlQualifiedName, string> tAttrs =
+                Nodes.GetAttributes(testElement, attributeFiler);
+            if (cAttrs.Count != tAttrs.Count) {
+                return false;
+            }
+            return MapsEqualForKeys(cAttrs, tAttrs, cAttrs.Keys);
+        }
+
     }
 }

src/main/net-core/Diff/IDifferenceEngine.cs

@@ -82,6 +82,12 @@ public interface IDifferenceEngine {
         /// If you want to suppress comparison of them you'll need to
         /// implement <see cref="DifferenceEvaluator"/>
         ///   </para>
+        ///   <para>
+        /// Note that NodeMatcher will not by aware of the configured
+        /// attribute filter and if its decision is based on
+        /// attributes it will in general also consider attributes the
+        /// filter would suppress.
+        ///   </para>
         /// </remarks>
         Predicate<XmlAttribute> AttributeFilter { set; }
 
@@ -105,4 +111,4 @@ public interface IDifferenceEngine {
         /// <param name="test">the document to test</param>
         void Compare(ISource control, ISource test);
     }
-}
+}

src/main/net-core/Util/Nodes.cs

@@ -12,6 +12,7 @@ the License.  You may obtain a copy of the License at
   limitations under the License.
 */
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -51,9 +52,23 @@ public static string GetMergedNestedText(XmlNode n) {
         /// </summary>
         public static IDictionary<XmlQualifiedName, string>
             GetAttributes(XmlNode n) {
+            return GetAttributes(n, ignored => true);
+        }
+
+        /// <summary>
+        /// Obtains an element's attributes as dictionary.
+        /// </summary>
+        /// <remarks>
+        ///  <para>
+        /// since XMLUnit 2.9.3
+        ///  </para>
+        /// </remarks>
+        public static IDictionary<XmlQualifiedName, string>
+            GetAttributes(XmlNode n, Predicate<XmlAttribute> attributeFilter) {
             XmlAttributeCollection coll = n.Attributes;
             if (coll != null) {
                 return coll.Cast<XmlAttribute>()
+                    .Where(a => attributeFilter(a))
                     .ToDictionary<XmlAttribute, XmlQualifiedName, string>(GetQName,
                                                                           a => a.Value);
             }

src/tests/net-core/Diff/ElementSelectorsTest.cs

@@ -117,6 +117,30 @@ [Test] public void ByNameAndAllAttributes() {
                                                                    differentNS));
         }
 
+        [Test] public void ByNameAndAllAttributesWithFilter() {
+            XmlElement control = doc.CreateElement(FOO);
+            control.SetAttribute(BAR, BAR);
+            XmlElement equal = doc.CreateElement(FOO);
+            equal.SetAttribute(BAR, BAR);
+            equal.SetAttribute("x", "y");
+            XmlElement noAttributes = doc.CreateElement(FOO);
+            XmlElement differentValue = doc.CreateElement(FOO);
+            differentValue.SetAttribute(BAR, FOO);
+            XmlElement differentName = doc.CreateElement(FOO);
+            differentName.SetAttribute(FOO, FOO);
+            XmlElement differentNS = doc.CreateElement(FOO);
+            differentNS.SetAttribute(BAR, SOME_URI, BAR);
+            Predicate<XmlAttribute> filter = a => BAR == a.Name;
+            ElementSelector es = ElementSelectors.ByNameAndAllAttributes(filter);
+
+            Assert.IsTrue(es(control, equal));
+            Assert.IsFalse(es(control, noAttributes));
+            Assert.IsFalse(es(noAttributes, control));
+            Assert.IsFalse(es(control, differentValue));
+            Assert.IsFalse(es(control, differentName));
+            Assert.IsFalse(es(control, differentNS));
+        }
+
         [Test] public void ByNameAndAttributes_NamePart() {
             PureElementNameComparisons(ElementSelectors
                                        .ByNameAndAttributes(new string[] {}));
@@ -559,4 +583,4 @@ public void ConditionalSelectorBuilderWontAllowMultipleDefaults() {
                 });
         }
     }
-}
+}

src/tests/net-core/Util/NodesTest.cs

@@ -123,6 +123,15 @@ [Test] public void AttributeIDictionarywithNS() {
             Assert.AreEqual(BAR, m[new XmlQualifiedName(FOO, SOME_URI)]);
         }
 
+        [Test] public void AttributeMapWithFilter() {
+            XmlElement e = doc.CreateElement(FOO);
+            e.SetAttribute(FOO, BAR);
+            e.SetAttribute("x", "y");
+            IDictionary<XmlQualifiedName, string> m = Nodes.GetAttributes(e, a => FOO == a.Name);
+            Assert.AreEqual(1, m.Count);
+            Assert.AreEqual(BAR, m[new XmlQualifiedName(FOO)]);
+        }
+
         private XmlDocument HandleWsSetup() {
             return Convert.ToDocument(InputBuilder.FromString(
                 "<root>\n"