feat: Dnf reduction and structural equality

3 files changed, 93 insertions, 0 deletions

diff --git a/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/MismatchDescribingDnfEqualityChecker.java b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/MismatchDescribingDnfEqualityChecker.java
new file mode 100644
index 00000000..aaab2e7e
--- /dev/null
+++ b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/MismatchDescribingDnfEqualityChecker.java
@@ -0,0 +1,43 @@
+package tools.refinery.store.query.tests;
+
+import org.hamcrest.Description;
+import tools.refinery.store.query.equality.DeepDnfEqualityChecker;
+
+class MismatchDescribingDnfEqualityChecker extends DeepDnfEqualityChecker {
+        private final Description description;
+        private boolean described;
+
+        MismatchDescribingDnfEqualityChecker(Description description) {
+                this.description = description;
+        }
+
+        public boolean isDescribed() {
+                return described;
+        }
+
+        @Override
+        protected boolean doCheckEqual(Pair pair) {
+                boolean result = super.doCheckEqual(pair);
+                if (!result && !described) {
+                        describeMismatch(pair);
+                        // Only describe the first found (innermost) mismatch.
+                        described = true;
+                }
+                return result;
+        }
+
+        private void describeMismatch(Pair pair) {
+                var inProgress = getInProgress();
+                int size = inProgress.size();
+                if (size <= 1) {
+                        description.appendText("was ").appendValue(pair.left());
+                        return;
+                }
+                var last = inProgress.get(size - 1);
+                description.appendText("expected ").appendValue(last.right());
+                for (int i = size - 2; i >= 0; i--) {
+                        description.appendText(" called from ").appendText(inProgress.get(i).left().name());
+                }
+                description.appendText(" was not structurally equal to ").appendValue(last.right());
+        }
+}
diff --git a/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/QueryMatchers.java b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/QueryMatchers.java
new file mode 100644
index 00000000..83614278
--- /dev/null
+++ b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/QueryMatchers.java
@@ -0,0 +1,14 @@
+package tools.refinery.store.query.tests;
+
+import org.hamcrest.Matcher;
+import tools.refinery.store.query.Dnf;
+
+public final class QueryMatchers {
+        private QueryMatchers() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Matcher<Dnf> structurallyEqualTo(Dnf expected) {
+                return new StructurallyEqualTo(expected);
+        }
+}
diff --git a/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/StructurallyEqualTo.java b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/StructurallyEqualTo.java
new file mode 100644
index 00000000..a42396dd
--- /dev/null
+++ b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/StructurallyEqualTo.java
@@ -0,0 +1,36 @@
+package tools.refinery.store.query.tests;
+
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeMatcher;
+import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.equality.DeepDnfEqualityChecker;
+
+public class StructurallyEqualTo extends TypeSafeMatcher<Dnf> {
+        private final Dnf expected;
+
+        public StructurallyEqualTo(Dnf expected) {
+                this.expected = expected;
+        }
+
+        @Override
+        protected boolean matchesSafely(Dnf item) {
+                var checker = new DeepDnfEqualityChecker();
+                return checker.dnfEqual(expected, item);
+        }
+
+        @Override
+        protected void describeMismatchSafely(Dnf item, Description mismatchDescription) {
+                var describingChecker = new MismatchDescribingDnfEqualityChecker(mismatchDescription);
+                if (describingChecker.dnfEqual(expected, item)) {
+                        throw new IllegalStateException("Mismatched Dnf was matching on repeated comparison");
+                }
+                if (!describingChecker.isDescribed()) {
+                        super.describeMismatchSafely(item, mismatchDescription);
+                }
+        }
+
+        @Override
+        public void describeTo(Description description) {
+                description.appendText("structurally equal to ").appendValue(expected);
+        }
+}