Merge branch 'feature-string-creater' into develop

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringAppend.java

 package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
 
+import static de.unikoblenz.fgbks.base.utils.boundary.bicreater.BoundaryBiCreaterType.COMBINE;
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_IN_CONTACT;
+
+import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
 import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
 import java.util.Optional;
 
@@ -22,6 +26,10 @@ public class BiCreaterStringAppend extends AbstractBoundaryBiCreater<StringBound
 
   @Override
   public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
-    return Optional.empty();
+    if (b1.checkWith(IS_IN_CONTACT, b2)) {
+      return Optional.empty();
+    }
+    Optional<Boundary> b = b1.createBi(COMBINE, b2);
+    return b.map(boundary -> (StringBoundary) boundary);
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringBetween.java

 package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
 
 import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.Optional;
+import java.util.Set;
 
 public class BiCreaterStringBetween extends AbstractBoundaryBiCreater<StringBoundary> {
 
@@ -22,6 +25,43 @@ public class BiCreaterStringBetween extends AbstractBoundaryBiCreater<StringBoun
 
   @Override
   public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
-    return Optional.empty();
+    if (b1.matchesAny() || b2.matchesAny()) {
+      return Optional.empty();
+    }
+    if (b1.matchesNoneOfValues() && b2.matchesNoneOfValues()) {
+      Set<String> vals1 = new HashSet<>(Arrays.asList(b1.getValues()));
+      Set<String> vals2 = new HashSet<>(Arrays.asList(b2.getValues()));
+      Set<String> values = new HashSet<>();
+      for (String v1 : vals1) {
+        if (vals2.contains(v1)) {
+          values.add(v1);
+        }
+      }
+      if (values.size() == 0) {
+        return Optional.empty();
+      }
+      return Optional.of(StringBoundary.getBuilder().addValues(values).build());
+    }
+    if (b1.matchesNoneOfValues()) {
+      return getOneIsNoneOfValues(b1, b2);
+    }
+    if (b2.matchesNoneOfValues()) {
+      return getOneIsNoneOfValues(b2, b1);
+    }
+    return Optional.of(
+        StringBoundary.getBuilder()
+            .matchesNoneOfValues(true)
+            .addValues(b1.getValues())
+            .addValues(b2.getValues())
+            .build());
+  }
+
+  private Optional<StringBoundary> getOneIsNoneOfValues(StringBoundary b1, StringBoundary b2) {
+    Set<String> values = new HashSet<>(Arrays.asList(b1.getValues()));
+    values.removeAll(Arrays.asList(b2.getValues()));
+    if (values.size() == 0) {
+      return Optional.empty();
+    }
+    return Optional.of(StringBoundary.getBuilder().addValues(values).build());
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringCombine.java

@@ -25,8 +25,8 @@ public class BiCreaterStringCombine extends AbstractBoundaryBiCreater<StringBoun
 
   @Override
   public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
-    if (b1.isMatchAny() || b2.isMatchAny()) {
-      return Optional.of(StringBoundary.getBuilder().isMatchAny(true).build());
+    if (b1.matchesAny() || b2.matchesAny()) {
+      return Optional.of(StringBoundary.getBuilder().matchesAny(true).build());
     }
     if (!b1.matchesNoneOfValues() && !b2.matchesNoneOfValues()) {
       return Optional.of(
@@ -42,9 +42,9 @@ public class BiCreaterStringCombine extends AbstractBoundaryBiCreater<StringBoun
     }
     return Optional.of(
         StringBoundary.getBuilder()
-            .isMatchNoneOfValues(true)
+            .matchesNoneOfValues(true)
             .addValues(values)
-            .isMatchAny(values.size() == 0)
+            .matchesAny(values.size() == 0)
             .build());
   }
 

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringIntersection.java

 package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
 
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_NOT_IN_CONTACT;
+
 import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
 
 public class BiCreaterStringIntersection extends AbstractBoundaryBiCreater<StringBoundary> {
 
@@ -22,6 +29,79 @@ public class BiCreaterStringIntersection extends AbstractBoundaryBiCreater<Strin
 
   @Override
   public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    if (b1.checkWith(IS_NOT_IN_CONTACT, b2)) {
+      return Optional.empty();
+    }
+    if (b1.matchesAny() && b2.matchesAny()
+        || b1.matchesAny() && !b2.matchesNoneOfValues()
+        || b2.matchesAny() && !b1.matchesNoneOfValues()) {
+      return Optional.of(StringBoundary.getBuilder().matchesAny(true).build());
+    }
+    if (b1.matchesAny() && b2.matchesNoneOfValues()) {
+      return Optional.of(
+          StringBoundary.getBuilder().matchesNoneOfValues(true).addValues(b2.getValues()).build());
+    }
+    if (b2.matchesAny() && b1.matchesNoneOfValues()) {
+      return Optional.of(
+          StringBoundary.getBuilder().matchesNoneOfValues(true).addValues(b1.getValues()).build());
+    }
+    if (b1.matchesNoneOfValues() && b2.matchesNoneOfValues()) {
+      Set<String> intersectionStrings = new HashSet<>();
+      intersectionStrings.addAll(Arrays.asList(b1.getValues()));
+      intersectionStrings.addAll(Arrays.asList(b2.getValues()));
+      if (intersectionStrings.size() == 0) {
+        return Optional.empty();
+      }
+      return Optional.of(
+          StringBoundary.getBuilder()
+              .matchesNoneOfValues(true)
+              .addValues(b1.getValues())
+              .addValues(b2.getValues())
+              .build());
+    }
+    if (!b1.matchesNoneOfValues() && !b2.matchesNoneOfValues()) {
+      Set<String> intersectionStrings = new HashSet<>();
+      String[] b1v = b1.getValues();
+      int[] b2Hashes = b2.getValuesHashes();
+      for (String s1 : b1v) {
+        int h1 = Objects.hashCode(s1);
+        for (int h2 : b2Hashes) {
+          if (h1 == h2) {
+            intersectionStrings.add(s1);
+            break;
+          }
+        }
+      }
+      return Optional.of(StringBoundary.getBuilder().addValues(intersectionStrings).build());
+    }
+    if (b1.matchesNoneOfValues()) {
+      return Optional.of(
+          StringBoundary.getBuilder()
+              .addValues(getIntersectionStrings(b2, b1))
+              .build());
+    }
+    if (b2.matchesNoneOfValues()) {
+      return Optional.of(
+          StringBoundary.getBuilder()
+              .addValues(getIntersectionStrings(b1, b2))
+              .build());
+    }
     return Optional.empty();
   }
+
+  private Set<String> getIntersectionStrings(StringBoundary b1, StringBoundary b2) {
+    Set<String> intersectionStrings = new HashSet<>(Arrays.asList(b1.getValues()));
+    int[] b2Hashes = b2.getValuesHashes();
+    for (Iterator<String> it = intersectionStrings.iterator(); it.hasNext(); ) {
+      String element = it.next();
+      int h1 = Objects.hashCode(element);
+      for (int h2 : b2Hashes) {
+        if (h1 == h2) {
+          it.remove();
+          break;
+        }
+      }
+    }
+    return intersectionStrings;
+  }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringLowerBounds.java

@@ -22,6 +22,8 @@ public class BiCreaterStringLowerBounds extends AbstractBoundaryBiCreater<String
 
   @Override
   public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    // Not supported for String Boundary
+    // Check BiCreaterStringBetween.
     return Optional.empty();
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringUpperBounds.java

@@ -22,6 +22,8 @@ public class BiCreaterStringUpperBounds extends AbstractBoundaryBiCreater<String
 
   @Override
   public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    // Not supported for String Boundary
+    // Check BiCreaterStringBetween.
     return Optional.empty();
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringEqual.java

@@ -25,7 +25,7 @@ public class CheckStringEqual extends AbstractBoundaryCheck<StringBoundary> {
   }
 
   public static boolean checkEqual(StringBoundary b1, StringBoundary b2) {
-    if (b1 == b2 || b1.getText().equals(b2.getText()) || b1.isMatchAny() && b2.isMatchAny()) {
+    if (b1 == b2 || b1.getText().equals(b2.getText()) || b1.matchesAny() && b2.matchesAny()) {
       return true;
     }
     if (b1.matchesNoneOfValues() != b2.matchesNoneOfValues()

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringInContact.java

@@ -25,8 +25,8 @@ public class CheckStringInContact extends AbstractBoundaryCheck<StringBoundary>
   }
 
   public static boolean checkInContact(StringBoundary b1, StringBoundary b2) {
-    if (b1.isMatchAny()
-        || b2.isMatchAny()
+    if (b1.matchesAny()
+        || b2.matchesAny()
         || b1.matchesNoneOfValues() && b2.matchesNoneOfValues()) {
       return true;
     }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumes.java

@@ -25,10 +25,10 @@ public class CheckStringSubsumes extends AbstractBoundaryCheck<StringBoundary> {
   }
 
   public static boolean checkSubsumes(StringBoundary b1, StringBoundary b2) {
-    if (b1.isMatchAny() && !b2.isMatchAny()) {
+    if (b1.matchesAny() && !b2.matchesAny()) {
       return true;
     }
-    if (b2.isMatchAny()) {
+    if (b2.matchesAny()) {
       return false;
     }
     int[] b1h = b1.getValuesHashes();

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringLower.java

@@ -24,8 +24,8 @@ public class CreaterStringLower extends AbstractBoundaryCreater<StringBoundary>
   public Optional<StringBoundary> create(StringBoundary b) {
     return Optional.of(StringBoundary.getBuilder()
         .addValues(b.getValues())
-        .isMatchNoneOfValues(!b.matchesNoneOfValues())
-        .isMatchAny(b.getAmountOfElements() == 0)
+        .matchesNoneOfValues(!b.matchesNoneOfValues())
+        .matchesAny(b.getAmountOfElements() == 0)
         .build());
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/impl/StringBoundary.java

@@ -39,14 +39,14 @@ import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreater;
 import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType;
 import de.unikoblenz.fgbks.base.utils.boundary.creater.CreaterStringLower;
 import de.unikoblenz.fgbks.base.utils.boundary.creater.CreaterStringUpper;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.Validate;
 
@@ -73,8 +73,8 @@ public class StringBoundary extends AbstractBoundary<String> {
     biCreaterMap.put(COMBINE, BiCreaterStringCombine.getInstance());
   }
 
-  private boolean matchNoneOfValues;
-  private boolean matchAny;
+  private boolean matchesNoneOfValues;
+  private boolean matchesAny;
   private String[] values;
   // sorted list of cached hashes of valuesHashes
   private int[] valuesHashes;
@@ -93,11 +93,11 @@ public class StringBoundary extends AbstractBoundary<String> {
   }
 
   public boolean matchesNoneOfValues() {
-    return matchNoneOfValues;
+    return matchesNoneOfValues;
   }
 
-  public boolean isMatchAny() {
-    return matchAny;
+  public boolean matchesAny() {
+    return matchesAny;
   }
 
   public String[] getValues() {
@@ -114,16 +114,16 @@ public class StringBoundary extends AbstractBoundary<String> {
 
   @Override
   protected void parse(String text) {
-    matchNoneOfValues = false;
-    matchAny = false;
+    matchesNoneOfValues = false;
+    matchesAny = false;
     try {
-      matchAny = Validate.notNull(text).isEmpty();
-      if (matchAny) {
+      matchesAny = Validate.notNull(text).isEmpty();
+      if (matchesAny) {
         values = new String[0];
       } else {
-        matchNoneOfValues = text.toLowerCase().startsWith("not");
+        matchesNoneOfValues = text.toLowerCase().startsWith("not");
         text = text.replace('(', '\0').replace(')', '\0').trim();
-        if (matchNoneOfValues) {
+        if (matchesNoneOfValues) {
           text = text.replaceFirst("not", "").trim();
         }
         values = text.split(",");
@@ -166,9 +166,9 @@ public class StringBoundary extends AbstractBoundary<String> {
 
   @Override
   public String getParsedText() {
-    return (matchNoneOfValues ? "not(" : "")
+    return (matchesNoneOfValues ? "not(" : "")
         + Arrays.stream(values).map(v -> '"' + v + '"').collect(Collectors.joining(","))
-        + (matchNoneOfValues ? ")" : "");
+        + (matchesNoneOfValues ? ")" : "");
   }
 
   public static Builder getBuilder() {
@@ -177,21 +177,21 @@ public class StringBoundary extends AbstractBoundary<String> {
 
   public class Builder extends DefaultBuilder<StringBoundary> {
 
-    private List<String> buildingValues;
+    private Set<String> buildingValues;
 
     private Builder() {
-      buildingValues = new ArrayList<>();
-      value.matchAny = false;
-      value.matchNoneOfValues = false;
+      buildingValues = new HashSet<>();
+      value.matchesAny = false;
+      value.matchesNoneOfValues = false;
     }
 
-    public Builder isMatchNoneOfValues(boolean matchNoneOfValues) {
-      value.matchNoneOfValues = matchNoneOfValues;
+    public Builder matchesNoneOfValues(boolean matchesNoneOfValues) {
+      value.matchesNoneOfValues = matchesNoneOfValues;
       return this;
     }
 
-    public Builder isMatchAny(boolean matchAny) {
-      value.matchAny = matchAny;
+    public Builder matchesAny(boolean matchAny) {
+      value.matchesAny = matchAny;
       return this;
     }
 
@@ -209,19 +209,11 @@ public class StringBoundary extends AbstractBoundary<String> {
       return addValues(Validate.notNull(Arrays.asList(values)));
     }
 
-    @Override
-    protected void validate() {
-      super.validate();
-      if (matchAny) {
-        // TODO exception
-      }
-    }
-
     @Override
     public StringBoundary build() {
       value.values = buildingValues.toArray(new String[0]);
-      if (value.matchAny) {
-        value.matchNoneOfValues = false;
+      if (value.matchesAny) {
+        value.matchesNoneOfValues = false;
         value.values = new String[0];
       }
       value.calcHashes();

dmnverifierapi/src/test/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringBetweenTest.java

+package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
+
+import static de.unikoblenz.fgbks.base.utils.boundary.bicreater.BoundaryBiCreaterType.BETWEEN;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class BiCreaterStringBetweenTest {
+
+  StringBoundary sb1;
+  StringBoundary sb2;
+  StringBoundary sbR;
+
+  @Test
+  void testCreater() {
+    sb1 = StringBoundary.getBuilder().addValue("a").build();
+    sb2 = StringBoundary.getBuilder().addValue("b").build();
+    sbR = (StringBoundary) sb1.createBi(BETWEEN, sb2).get();
+    assertArrayEquals(new String[]{"a", "b"}, sbR.getValues());
+    assertTrue(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").matchesNoneOfValues(true).build();
+    sb2 = StringBoundary.getBuilder().addValue("b").build();
+    sbR = (StringBoundary) sb1.createBi(BETWEEN, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").matchesNoneOfValues(true).build();
+    sb2 = StringBoundary.getBuilder().addValue("a").build();
+    assertFalse(sb1.createBi(BETWEEN, sb2).isPresent());
+    assertFalse(sb2.createBi(BETWEEN, sb1).isPresent());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").matchesNoneOfValues(true).build();
+    sb2 = StringBoundary.getBuilder().addValue("b").matchesNoneOfValues(true).build();
+    assertFalse(sb1.createBi(BETWEEN, sb2).isPresent());
+    assertFalse(sb2.createBi(BETWEEN, sb1).isPresent());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").matchesNoneOfValues(true).build();
+    sb2 = StringBoundary.getBuilder().addValue("a").matchesNoneOfValues(true).build();
+    sbR = (StringBoundary) sb1.createBi(BETWEEN, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 =
+        StringBoundary.getBuilder()
+            .addValue("a")
+            .addValue("b")
+            .addValue("c")
+            .matchesNoneOfValues(true)
+            .build();
+    sb2 = StringBoundary.getBuilder().addValue("a").matchesNoneOfValues(true).build();
+    sbR = (StringBoundary) sb1.createBi(BETWEEN, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").build();
+    sb2 = StringBoundary.getBuilder().addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(BETWEEN, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertTrue(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+  }
+}

dmnverifierapi/src/test/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringCombineTest.java

@@ -23,55 +23,55 @@ class BiCreaterStringCombineTest {
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{"a", "b"}, sbR.getValues());
     assertFalse(sbR.matchesNoneOfValues());
-    assertFalse(sbR.isMatchAny());
+    assertFalse(sbR.matchesAny());
 
-    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("a").build();
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
     sb2 = StringBoundary.getBuilder().addValue("b").build();
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{"a"}, sbR.getValues());
     assertTrue(sbR.matchesNoneOfValues());
-    assertFalse(sbR.isMatchAny());
+    assertFalse(sbR.matchesAny());
 
-    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("a").addValue("b").build();
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").addValue("b").build();
     sb2 = StringBoundary.getBuilder().addValue("b").build();
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{"a"}, sbR.getValues());
     assertTrue(sbR.matchesNoneOfValues());
-    assertFalse(sbR.isMatchAny());
+    assertFalse(sbR.matchesAny());
 
     sb1 = StringBoundary.getBuilder().addValue("b").build();
-    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("a").addValue("b").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").addValue("b").build();
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{"a"}, sbR.getValues());
     assertTrue(sbR.matchesNoneOfValues());
-    assertFalse(sbR.isMatchAny());
+    assertFalse(sbR.matchesAny());
 
-    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("a").build();
-    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("b").build();
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("b").build();
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{}, sbR.getValues());
     assertFalse(sbR.matchesNoneOfValues());
-    assertTrue(sbR.isMatchAny());
+    assertTrue(sbR.matchesAny());
 
-    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("a").build();
-    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("b").addValue("a").build();
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("b").addValue("a").build();
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{"a"}, sbR.getValues());
     assertTrue(sbR.matchesNoneOfValues());
-    assertFalse(sbR.isMatchAny());
+    assertFalse(sbR.matchesAny());
 
-    sb1 = StringBoundary.getBuilder().isMatchAny(true).build();
-    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("b").addValue("a").build();
+    sb1 = StringBoundary.getBuilder().matchesAny(true).build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("b").addValue("a").build();
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{}, sbR.getValues());
     assertFalse(sbR.matchesNoneOfValues());
-    assertTrue(sbR.isMatchAny());
+    assertTrue(sbR.matchesAny());
 
-    sb1 = StringBoundary.getBuilder().isMatchAny(true).build();
-    sb2 = StringBoundary.getBuilder().isMatchAny(true).build();
+    sb1 = StringBoundary.getBuilder().matchesAny(true).build();
+    sb2 = StringBoundary.getBuilder().matchesAny(true).build();
     sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
     assertArrayEquals(new String[]{}, sbR.getValues());
     assertFalse(sbR.matchesNoneOfValues());
-    assertTrue(sbR.isMatchAny());
+    assertTrue(sbR.matchesAny());
   }
 }

dmnverifierapi/src/test/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringIntersectionTest.java

+package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
+
+import static de.unikoblenz.fgbks.base.utils.boundary.bicreater.BoundaryBiCreaterType.INTERSECTION;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class BiCreaterStringIntersectionTest {
+
+  StringBoundary sb1;
+  StringBoundary sb2;
+  StringBoundary sbR;
+
+  @Test
+  void testCreater() {
+    sb1 = StringBoundary.getBuilder().addValue("a").build();
+    sb2 = StringBoundary.getBuilder().addValue("b").build();
+    assertFalse(sb1.createBi(INTERSECTION, sb2).isPresent());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").build();
+    sb2 = StringBoundary.getBuilder().addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesAny(true).build();
+    sb2 = StringBoundary.getBuilder().matchesAny(true).build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertTrue(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesAny(true).build();
+    sb2 = StringBoundary.getBuilder().addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertTrue(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").build();
+    sb2 = StringBoundary.getBuilder().matchesAny(true).build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertTrue(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesAny(true).build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertTrue(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sb2 = StringBoundary.getBuilder().matchesAny(true).build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertTrue(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a"}, sbR.getValues());
+    assertTrue(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").addValue("b").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a", "b"}, sbR.getValues());
+    assertTrue(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").addValue("b").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a", "b"}, sbR.getValues());
+    assertTrue(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").addValue("b").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"b"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").addValue("b").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("a").addValue("b").build();
+    assertFalse(sb1.createBi(INTERSECTION, sb2).isPresent());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").addValue("b").build();
+    sb2 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("c").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a", "b"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().matchesNoneOfValues(true).addValue("c").build();
+    sb2 = StringBoundary.getBuilder().addValue("a").addValue("b").build();
+    sbR = (StringBoundary) sb1.createBi(INTERSECTION, sb2).get();
+    assertArrayEquals(new String[]{"a", "b"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+  }
+}

dmnverifierapi/src/test/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringLowerTest.java

@@ -16,13 +16,13 @@ class CreaterStringLowerTest {
   public void testStringLower() {
     StringBoundary sb = StringBoundary.getBuilder().addValue("a").build();
     assertEquals("a", sb.getValues()[0]);
-    assertFalse(sb.isMatchAny());
+    assertFalse(sb.matchesAny());
     assertFalse(sb.matchesNoneOfValues());
     assertEquals("\"a\"", sb.getText());
 
     StringBoundary sb2 = (StringBoundary) sb.create(BoundaryCreaterType.LOWER).get();
     assertArrayEquals(sb.getValues(), sb2.getValues());
     assertTrue(sb2.matchesNoneOfValues());
-    assertFalse(sb.isMatchAny());
+    assertFalse(sb.matchesAny());
   }
 }

dmnverifierapi/src/test/java/de/unikoblenz/fgbks/base/utils/boundary/impl/StringBoundaryTest.java

@@ -11,13 +11,13 @@ class StringBoundaryTest {
   public void testBuilder() {
     StringBoundary sb = StringBoundary.getBuilder().addValue("a").build();
     Assertions.assertEquals("a", sb.getValues()[0]);
-    Assertions.assertFalse(sb.isMatchAny());
+    Assertions.assertFalse(sb.matchesAny());
     Assertions.assertFalse(sb.matchesNoneOfValues());
     Assertions.assertEquals("\"a\"", sb.getText());
 
-    sb = StringBoundary.getBuilder().addValue("a").addValue("b").isMatchNoneOfValues(true).build();
+    sb = StringBoundary.getBuilder().addValue("a").addValue("b").matchesNoneOfValues(true).build();
     Assertions.assertEquals("a", sb.getValues()[0]);
-    Assertions.assertFalse(sb.isMatchAny());
+    Assertions.assertFalse(sb.matchesAny());
     Assertions.assertTrue(sb.matchesNoneOfValues());
     Assertions.assertEquals("not(\"a\",\"b\")", sb.getText());
   }