From 4553a263934c6367dfbebf38308c7fb50f9ea9e4 Mon Sep 17 00:00:00 2001
From: Stefan Bodewig <stefan.bodewig@freenet.de>
Date: Thu, 16 Dec 2021 18:29:36 +0100
Subject: [PATCH] port xmlunit/#236

---
 RELEASE_NOTES.md                              |  4 +++
 src/main/net-core/Diff/DOMDifferenceEngine.cs | 36 +++++++++++++------
 2 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 97b5fe6..7d04737 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -2,6 +2,10 @@
 
 ## XMLUnit.NET 2.9.1 - /not released, yet/
 
+* improved comparison performance for documents with many siblings
+  based on a suggestion by [@gerpres](https://github.com/gerpres) made
+  in Java Issue [xmlunit/#236](https://github.com/xmlunit/xmlunit/issues/236)
+
 * added a new `FullDescription` method to `Diff` that provides a
   string-representation of all differences - not just the first one
   like `ToString` does.
diff --git a/src/main/net-core/Diff/DOMDifferenceEngine.cs b/src/main/net-core/Diff/DOMDifferenceEngine.cs
index 8fc3fd0..6a1d90a 100644
--- a/src/main/net-core/Diff/DOMDifferenceEngine.cs
+++ b/src/main/net-core/Diff/DOMDifferenceEngine.cs
@@ -472,16 +472,22 @@ private ComparisonState CompareNodeLists(IEnumerable<XmlNode> allControlChildren
             IList<XmlNode> testListForXpath = new List<XmlNode>(allTestChildren);
             IList<XmlNode> controlList = new List<XmlNode>(controlSeq);
             IList<XmlNode> testList = new List<XmlNode>(testSeq);
+
+            IDictionary<XmlNode, int> controlListForXpathIndex = Index(controlListForXpath);
+            IDictionary<XmlNode, int> testListForXpathIndex = Index(testListForXpath);
+            IDictionary<XmlNode, int> controlListIndex = Index(controlList);
+            IDictionary<XmlNode, int> testListIndex = Index(testList);
+
             ICollection<XmlNode> seen = new HashSet<XmlNode>();
             foreach (KeyValuePair<XmlNode, XmlNode> pair in matches) {
                 XmlNode control = pair.Key;
                 seen.Add(control);
                 XmlNode test = pair.Value;
                 seen.Add(test);
-                int controlIndexForXpath = controlListForXpath.IndexOf(control);
-                int testIndexForXpath = testListForXpath.IndexOf(test);
-                int controlIndex = controlList.IndexOf(control);
-                int testIndex = testList.IndexOf(test);
+                int controlIndexForXpath = controlListForXpathIndex[control];
+                int testIndexForXpath = testListForXpathIndex[test];
+                int controlIndex = controlListIndex[control];
+                int testIndex = testListIndex[test];
                 controlContext.NavigateToChild(controlIndexForXpath);
                 testContext.NavigateToChild(testIndexForXpath);
                 try {
@@ -500,13 +506,13 @@ private ComparisonState CompareNodeLists(IEnumerable<XmlNode> allControlChildren
             }
 
             return chain
-                .AndThen(UnmatchedControlNodes(controlListForXpath, controlList, controlContext,
+                .AndThen(UnmatchedControlNodes(controlListForXpathIndex, controlList, controlContext,
                     seen, testContext))
-                .AndThen(UnmatchedTestNodes(testListForXpath, testList, testContext, seen,
-                    controlContext));
+                .AndThen(UnmatchedTestNodes(testListForXpathIndex, testList, testContext,
+                    seen, controlContext));
         }
 
-        private Func<ComparisonState> UnmatchedControlNodes(IList<XmlNode> controlListForXpath,
+        private Func<ComparisonState> UnmatchedControlNodes(IDictionary<XmlNode, int> controlListForXpathIndex,
                                                             IList<XmlNode> controlList,
                                                             XPathContext controlContext,
                                                             ICollection<XmlNode> seen,
@@ -517,7 +523,7 @@ private Func<ComparisonState> UnmatchedControlNodes(IList<XmlNode> controlListFo
                 for (int i = 0; i < controlSize; i++) {
                     if (!seen.Contains(controlList[i])) {
                         controlContext
-                            .NavigateToChild(controlListForXpath.IndexOf(controlList[i]));
+                            .NavigateToChild(controlListForXpathIndex[controlList[i]]);
                         try {
                             chain = chain
                                 .AndThen(new Comparison(ComparisonType.CHILD_LOOKUP,
@@ -536,7 +542,7 @@ private Func<ComparisonState> UnmatchedControlNodes(IList<XmlNode> controlListFo
             };
         }
 
-        private Func<ComparisonState> UnmatchedTestNodes(IList<XmlNode> testListForXpath,
+        private Func<ComparisonState> UnmatchedTestNodes(IDictionary<XmlNode, int>  testListForXpathIndex,
                                                          IList<XmlNode> testList,
                                                          XPathContext testContext,
                                                          ICollection<XmlNode> seen,
@@ -546,7 +552,7 @@ private Func<ComparisonState> UnmatchedTestNodes(IList<XmlNode> testListForXpath
                 int testSize = testList.Count;
                 for (int i = 0; i < testSize; i++) {
                     if (!seen.Contains(testList[i])) {
-                        testContext.NavigateToChild(testListForXpath.IndexOf(testList[i]));
+                        testContext.NavigateToChild(testListForXpathIndex[testList[i]]);
                         try {
                             chain = chain
                                 .AndThen(new Comparison(ComparisonType.CHILD_LOOKUP,
@@ -737,5 +743,13 @@ private static XmlAttribute FindMatchingAttr(IList<XmlAttribute> attrs,
             return null;
         }
 
+        private static IDictionary<XmlNode, int> Index(IList<XmlNode> nodes) {
+            IDictionary<XmlNode, int> indices = new Dictionary<XmlNode, int>();
+            int idx = 0;
+            foreach (XmlNode n in nodes) {
+                indices[n] = idx++;
+            }
+            return indices;
+        }
     }
 }