feat: data structure for default assertions

1 files changed, 88 insertions, 1 deletions

diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/tests/DecisionTreeTests.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/tests/DecisionTreeTests.java
index 5268eb8a..f171e5c7 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/tests/DecisionTreeTests.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/tests/DecisionTreeTests.java
@@ -2,14 +2,15 @@ package tools.refinery.language.semantics.model.tests;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.language.semantics.model.internal.DecisionTree;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class DecisionTreeTests {
         @Test
@@ -165,6 +166,25 @@ class DecisionTreeTests {
         }
 
         @Test
+        void reducedValueEmptyTest() {
+                var sut = new DecisionTree(2, TruthValue.TRUE);
+                assertThat(sut.getReducedValue(), is(TruthValue.TRUE));
+        }
+
+        @Test
+        void reducedValueUnsetTest() {
+                var sut = new DecisionTree(2);
+                assertThat(sut.getReducedValue(), is(nullValue()));
+        }
+
+        @Test
+        void reducedValueNonEmptyTest() {
+                var sut = new DecisionTree(2, TruthValue.UNKNOWN);
+                sut.mergeValue(Tuple.of(1, 2), TruthValue.TRUE);
+                assertThat(sut.getReducedValue(), is(nullValue()));
+        }
+
+        @Test
         void removeIntermediateChildTest() {
                 var sut = new DecisionTree(3, TruthValue.TRUE);
                 var values = new DecisionTree(3, null);
@@ -172,6 +192,73 @@ class DecisionTreeTests {
                 sut.overwriteValues(values);
                 sut.mergeValue(Tuple.of(1, 1, 1), TruthValue.TRUE);
                 assertThat(sut.get(Tuple.of(1, 1, 1)), is(TruthValue.TRUE));
+                assertThat(sut.getReducedValue(), is(TruthValue.TRUE));
+        }
+
+        @Test
+        void setMissingValueTest() {
+                var sut = new DecisionTree(2);
+                sut.setIfMissing(Tuple.of(0, 0), TruthValue.FALSE);
+                assertThat(sut.get(Tuple.of(0, 0)), is(TruthValue.FALSE));
+        }
+
+        @Test
+        void setNotMissingValueTest() {
+                var sut = new DecisionTree(2);
+                sut.mergeValue(Tuple.of(0, 0), TruthValue.TRUE);
+                sut.setIfMissing(Tuple.of(0, 0), TruthValue.FALSE);
+                assertThat(sut.get(Tuple.of(0, 0)), is(TruthValue.TRUE));
+        }
+
+        @Test
+        void setNotMissingDefaultValueTest() {
+                var sut = new DecisionTree(2, TruthValue.TRUE);
+                sut.setIfMissing(Tuple.of(0, 0), TruthValue.FALSE);
+                assertThat(sut.get(Tuple.of(0, 0)), is(TruthValue.TRUE));
+        }
+
+        @Test
+        void setMissingValueWildcardTest() {
+                var sut = new DecisionTree(2);
+                sut.mergeValue(Tuple.of(-1, 0), TruthValue.TRUE);
+                sut.mergeValue(Tuple.of(1, -1), TruthValue.TRUE);
+                sut.setIfMissing(Tuple.of(0, 0), TruthValue.FALSE);
+                sut.setIfMissing(Tuple.of(1, 1), TruthValue.FALSE);
+                sut.setIfMissing(Tuple.of(2, 2), TruthValue.FALSE);
+                assertThat(sut.get(Tuple.of(0, 0)), is(TruthValue.TRUE));
+                assertThat(sut.get(Tuple.of(1, 1)), is(TruthValue.TRUE));
+                assertThat(sut.get(Tuple.of(2, 2)), is(TruthValue.FALSE));
+                assertThat(sut.get(Tuple.of(2, 3)), is(nullValue()));
+        }
+
+        @Test
+        void setMissingValueInvalidTupleTest() {
+                var sut = new DecisionTree(2);
+                var tuple = Tuple.of(-1, -1);
+                assertThrows(IllegalArgumentException.class, () -> sut.setIfMissing(tuple, TruthValue.TRUE));
+        }
+
+        @Test
+        void setAllMissingTest() {
+                var sut = new DecisionTree(2);
+                sut.mergeValue(Tuple.of(-1, 0), TruthValue.TRUE);
+                sut.mergeValue(Tuple.of(1, -1), TruthValue.TRUE);
+                sut.mergeValue(Tuple.of(2, 2), TruthValue.TRUE);
+                sut.setAllMissing(TruthValue.FALSE);
+                assertThat(sut.get(Tuple.of(0, 0)), is(TruthValue.TRUE));
+                assertThat(sut.get(Tuple.of(2, 0)), is(TruthValue.TRUE));
+                assertThat(sut.get(Tuple.of(1, 1)), is(TruthValue.TRUE));
+                assertThat(sut.get(Tuple.of(1, 2)), is(TruthValue.TRUE));
+                assertThat(sut.get(Tuple.of(2, 2)), is(TruthValue.TRUE));
+                assertThat(sut.get(Tuple.of(2, 3)), is(TruthValue.FALSE));
+                assertThat(sut.get(Tuple.of(3, 2)), is(TruthValue.FALSE));
+        }
+
+        @Test
+        void setAllMissingEmptyTest() {
+                var sut = new DecisionTree(2);
+                sut.setAllMissing(TruthValue.TRUE);
+                assertThat(sut.getReducedValue(), is(TruthValue.TRUE));
         }
 
         private Map<Tuple, TruthValue> iterateAll(DecisionTree sut, TruthValue defaultValue, int nodeCount) {