Merge branch 'feature-string-creater' into develop

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

@@ -9,6 +9,7 @@ import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType;
 import de.unikoblenz.fgbks.base.utils.boundary.impl.InvalidBoundary;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VTypeRef;
 import java.util.HashMap;
+import java.util.Map;
 import java.util.Optional;
 import org.apache.commons.lang3.Validate;
 
@@ -18,7 +19,7 @@ public abstract class AbstractBoundary<T extends Comparable<? super T>> implemen
   private HashMap<BoundaryBiCreaterType, BoundaryBiCreater> biCreaterFunctions;
   private HashMap<BoundaryCreaterType, BoundaryCreater> createrFunctions;
   private Class<T> type;
-  private String text;
+  protected String text;
 
   protected AbstractBoundary(String text, Class<T> type) {
     this.text = text;
@@ -113,11 +114,11 @@ public abstract class AbstractBoundary<T extends Comparable<? super T>> implemen
 
   protected abstract void validate();
 
-  protected abstract HashMap<BoundaryCheckType, BoundaryCheck> getChecker();
+  protected abstract Map<BoundaryCheckType, BoundaryCheck> getChecker();
 
-  protected abstract HashMap<BoundaryBiCreaterType, BoundaryBiCreater> getBiCreater();
+  protected abstract Map<BoundaryBiCreaterType, BoundaryBiCreater> getBiCreater();
 
-  protected abstract HashMap<BoundaryCreaterType, BoundaryCreater> getCreater();
+  protected abstract Map<BoundaryCreaterType, BoundaryCreater> getCreater();
 
   @Override
   public String toString() {

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

@@ -36,7 +36,9 @@ 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.CreaterLower;
 import de.unikoblenz.fgbks.base.utils.boundary.creater.CreaterUpper;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.Map;
 import java.util.Objects;
 import org.apache.commons.lang3.Validate;
 
@@ -117,18 +119,18 @@ public abstract class AbstractGrowingBoundary<T extends Comparable<? super T>>
   }
 
   @Override
-  protected HashMap<BoundaryCheckType, BoundaryCheck> getChecker() {
-    return checkerMap;
+  protected Map<BoundaryCheckType, BoundaryCheck> getChecker() {
+    return Collections.unmodifiableMap(checkerMap);
   }
 
   @Override
-  protected HashMap<BoundaryBiCreaterType, BoundaryBiCreater> getBiCreater() {
-    return biCreaterMap;
+  protected Map<BoundaryBiCreaterType, BoundaryBiCreater> getBiCreater() {
+    return Collections.unmodifiableMap(biCreaterMap);
   }
 
   @Override
-  protected HashMap<BoundaryCreaterType, BoundaryCreater> getCreater() {
-    return createrMap;
+  protected Map<BoundaryCreaterType, BoundaryCreater> getCreater() {
+    return Collections.unmodifiableMap(createrMap);
   }
 
   @Override

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

+package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Optional;
+
+public class BiCreaterStringAppend extends AbstractBoundaryBiCreater<StringBoundary> {
+
+  private static final BiCreaterStringAppend instance = new BiCreaterStringAppend();
+
+  private BiCreaterStringAppend() {
+    super();
+  }
+
+  public static BiCreaterStringAppend getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryBiCreaterType getType() {
+    return BoundaryBiCreaterType.APPEND;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    return Optional.empty();
+  }
+}

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.Optional;
+
+public class BiCreaterStringBetween extends AbstractBoundaryBiCreater<StringBoundary> {
+
+  private static final BiCreaterStringBetween instance = new BiCreaterStringBetween();
+
+  private BiCreaterStringBetween() {
+    super();
+  }
+
+  public static BiCreaterStringBetween getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryBiCreaterType getType() {
+    return BoundaryBiCreaterType.BETWEEN;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    return Optional.empty();
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringCombine.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 BiCreaterStringCombine extends AbstractBoundaryBiCreater<StringBoundary> {
+
+  private static final BiCreaterStringCombine instance = new BiCreaterStringCombine();
+
+  private BiCreaterStringCombine() {
+    super();
+  }
+
+  public static BiCreaterStringCombine getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryBiCreaterType getType() {
+    return BoundaryBiCreaterType.COMBINE;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    if (b1.isMatchAny() || b2.isMatchAny()) {
+      return Optional.of(StringBoundary.getBuilder().isMatchAny(true).build());
+    }
+    if (!b1.matchesNoneOfValues() && !b2.matchesNoneOfValues()) {
+      return Optional.of(
+          StringBoundary.getBuilder().addValues(b1.getValues()).addValues(b2.getValues()).build());
+    }
+    Set<String> values = new HashSet<>();
+    if (b1.matchesNoneOfValues() && b2.matchesNoneOfValues()) {
+      values = intersection(b1.getValues(), b2.getValues());
+    } else if (b1.matchesNoneOfValues()) {
+      values = leftInter(b1.getValues(), b2.getValues());
+    } else if (b2.matchesNoneOfValues()) {
+      values = leftInter(b2.getValues(), b1.getValues());
+    }
+    return Optional.of(
+        StringBoundary.getBuilder()
+            .isMatchNoneOfValues(true)
+            .addValues(values)
+            .isMatchAny(values.size() == 0)
+            .build());
+  }
+
+  private Set<String> leftInter(String[] values1, String[] values2) {
+    Set<String> vals = new HashSet<>(Arrays.asList(values1));
+    for (String v : values2) {
+      vals.removeIf(x -> x.equals(v));
+    }
+    return vals;
+  }
+
+  private Set<String> intersection(String[] values1, String[] values2) {
+    Set<String> vals = new HashSet<>();
+    for (String v1 : values1) {
+      for (String v2 : values2) {
+        if (v1.equals(v2)) {
+          vals.add(v1);
+        }
+      }
+    }
+    return vals;
+  }
+}

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

+package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Optional;
+
+public class BiCreaterStringIntersection extends AbstractBoundaryBiCreater<StringBoundary> {
+
+  private static final BiCreaterStringIntersection instance = new BiCreaterStringIntersection();
+
+  private BiCreaterStringIntersection() {
+    super();
+  }
+
+  public static BiCreaterStringIntersection getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryBiCreaterType getType() {
+    return BoundaryBiCreaterType.INTERSECTION;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    return Optional.empty();
+  }
+}

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

+package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Optional;
+
+public class BiCreaterStringLowerBounds extends AbstractBoundaryBiCreater<StringBoundary> {
+
+  private static final BiCreaterStringLowerBounds instance = new BiCreaterStringLowerBounds();
+
+  private BiCreaterStringLowerBounds() {
+    super();
+  }
+
+  public static BiCreaterStringLowerBounds getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryBiCreaterType getType() {
+    return BoundaryBiCreaterType.LOWER_BOUNDS;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    return Optional.empty();
+  }
+}

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

+package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Optional;
+
+public class BiCreaterStringUpperBounds extends AbstractBoundaryBiCreater<StringBoundary> {
+
+  private static final BiCreaterStringUpperBounds instance = new BiCreaterStringUpperBounds();
+
+  private BiCreaterStringUpperBounds() {
+    super();
+  }
+
+  public static BiCreaterStringUpperBounds getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryBiCreaterType getType() {
+    return BoundaryBiCreaterType.UPPER_BOUNDS;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
+    return Optional.empty();
+  }
+}

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

+package de.unikoblenz.fgbks.base.utils.boundary.creater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Optional;
+
+public class CreaterStringLower extends AbstractBoundaryCreater<StringBoundary> {
+
+  private static final CreaterStringLower instance = new CreaterStringLower();
+
+  private CreaterStringLower() {
+    super();
+  }
+
+  public static CreaterStringLower getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryCreaterType getType() {
+    return BoundaryCreaterType.LOWER;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b) {
+    return Optional.of(StringBoundary.getBuilder()
+        .addValues(b.getValues())
+        .isMatchNoneOfValues(!b.matchesNoneOfValues())
+        .isMatchAny(b.getAmountOfElements() == 0)
+        .build());
+  }
+}

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

+package de.unikoblenz.fgbks.base.utils.boundary.creater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import java.util.Optional;
+
+public class CreaterStringUpper extends AbstractBoundaryCreater<StringBoundary> {
+
+  private static final CreaterStringUpper instance = new CreaterStringUpper();
+
+  private CreaterStringUpper() {
+    super();
+  }
+
+  public static CreaterStringUpper getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryCreaterType getType() {
+    return BoundaryCreaterType.UPPER;
+  }
+
+  @Override
+  public Optional<StringBoundary> create(StringBoundary b) {
+    // is every time empty, because there is no "Upper", the result for "Upper" is
+    // inside the class CreaterStringLower
+    return Optional.empty();
+  }
+}

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

@@ -15,12 +15,18 @@ import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.
 import static de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType.LOWER;
 import static de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType.UPPER;
 
+import de.unikoblenz.fgbks.base.builder.DefaultBuilder;
 import de.unikoblenz.fgbks.base.utils.boundary.AbstractBoundary;
 import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
 import de.unikoblenz.fgbks.base.utils.boundary.BoundaryParseException;
+import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BiCreaterStringAppend;
+import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BiCreaterStringBetween;
+import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BiCreaterStringCombine;
+import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BiCreaterStringIntersection;
+import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BiCreaterStringLowerBounds;
+import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BiCreaterStringUpperBounds;
 import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BoundaryBiCreater;
 import de.unikoblenz.fgbks.base.utils.boundary.bicreater.BoundaryBiCreaterType;
-import de.unikoblenz.fgbks.base.utils.boundary.bicreater.EmptyBiCreater;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheck;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckStringEqual;
@@ -31,10 +37,15 @@ import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckStringSubsumes;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckStringSubsumption;
 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.CreaterLower;
-import de.unikoblenz.fgbks.base.utils.boundary.creater.CreaterUpper;
+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.Map;
 import java.util.Objects;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.Validate;
@@ -52,14 +63,14 @@ public class StringBoundary extends AbstractBoundary<String> {
     checkerMap.put(IS_OVERLAPPING, CheckStringOverlap.getInstance());
     checkerMap.put(IS_SUBSUMPTION, CheckStringSubsumption.getInstance());
     checkerMap.put(SUBSUMES, CheckStringSubsumes.getInstance());
-    createrMap.put(UPPER, CreaterUpper.getInstance());
-    createrMap.put(LOWER, CreaterLower.getInstance());
-    biCreaterMap.put(INTERSECTION, EmptyBiCreater.getInstance());
-    biCreaterMap.put(LOWER_BOUNDS, EmptyBiCreater.getInstance());
-    biCreaterMap.put(UPPER_BOUNDS, EmptyBiCreater.getInstance());
-    biCreaterMap.put(BETWEEN, EmptyBiCreater.getInstance());
-    biCreaterMap.put(APPEND, EmptyBiCreater.getInstance());
-    biCreaterMap.put(COMBINE, EmptyBiCreater.getInstance());
+    createrMap.put(UPPER, CreaterStringUpper.getInstance());
+    createrMap.put(LOWER, CreaterStringLower.getInstance());
+    biCreaterMap.put(INTERSECTION, BiCreaterStringIntersection.getInstance());
+    biCreaterMap.put(LOWER_BOUNDS, BiCreaterStringLowerBounds.getInstance());
+    biCreaterMap.put(UPPER_BOUNDS, BiCreaterStringUpperBounds.getInstance());
+    biCreaterMap.put(BETWEEN, BiCreaterStringBetween.getInstance());
+    biCreaterMap.put(APPEND, BiCreaterStringAppend.getInstance());
+    biCreaterMap.put(COMBINE, BiCreaterStringCombine.getInstance());
   }
 
   private boolean matchNoneOfValues;
@@ -72,6 +83,10 @@ public class StringBoundary extends AbstractBoundary<String> {
     super(text, String.class);
   }
 
+  private StringBoundary() {
+    super(String.class);
+  }
+
   @Override
   public int compareTo(Boundary o) {
     return o.getText().compareTo(o.getText());
@@ -105,7 +120,6 @@ public class StringBoundary extends AbstractBoundary<String> {
       matchAny = Validate.notNull(text).isEmpty();
       if (matchAny) {
         values = new String[0];
-        valuesHashes = new int[0];
       } else {
         matchNoneOfValues = text.toLowerCase().startsWith("not");
         text = text.replace('(', '\0').replace(')', '\0').trim();
@@ -113,37 +127,41 @@ public class StringBoundary extends AbstractBoundary<String> {
           text = text.replaceFirst("not", "").trim();
         }
         values = text.split(",");
-        valuesHashes = new int[values.length];
-        for (int i = 0; i < values.length; i++) {
-          values[i] = values[i].replace('"', '\0').trim();
-          valuesHashes[i] = Objects.hashCode(values[i]);
-        }
       }
-      // Sort hashes for later comparisons
-      Arrays.sort(valuesHashes);
+      calcHashes();
     } catch (Exception e) {
       throw new BoundaryParseException("String value is not valid: " + this.getText());
     }
   }
 
+  private void calcHashes() {
+    valuesHashes = new int[values.length];
+    for (int i = 0; i < values.length; i++) {
+      values[i] = values[i].replace('"', '\0').trim();
+      valuesHashes[i] = Objects.hashCode(values[i]);
+    }
+    // Sort hashes for later comparisons
+    Arrays.sort(valuesHashes);
+  }
+
   @Override
   protected void validate() {
     Validate.noNullElements(values);
   }
 
   @Override
-  protected HashMap<BoundaryCheckType, BoundaryCheck> getChecker() {
-    return checkerMap;
+  protected Map<BoundaryCheckType, BoundaryCheck> getChecker() {
+    return Collections.unmodifiableMap(checkerMap);
   }
 
   @Override
-  protected HashMap<BoundaryBiCreaterType, BoundaryBiCreater> getBiCreater() {
-    return biCreaterMap;
+  protected Map<BoundaryBiCreaterType, BoundaryBiCreater> getBiCreater() {
+    return Collections.unmodifiableMap(biCreaterMap);
   }
 
   @Override
-  protected HashMap<BoundaryCreaterType, BoundaryCreater> getCreater() {
-    return createrMap;
+  protected Map<BoundaryCreaterType, BoundaryCreater> getCreater() {
+    return Collections.unmodifiableMap(createrMap);
   }
 
   @Override
@@ -152,4 +170,63 @@ public class StringBoundary extends AbstractBoundary<String> {
         + Arrays.stream(values).map(v -> '"' + v + '"').collect(Collectors.joining(","))
         + (matchNoneOfValues ? ")" : "");
   }
+
+  public static Builder getBuilder() {
+    return new StringBoundary().new Builder();
+  }
+
+  public class Builder extends DefaultBuilder<StringBoundary> {
+
+    private List<String> buildingValues;
+
+    private Builder() {
+      buildingValues = new ArrayList<>();
+      value.matchAny = false;
+      value.matchNoneOfValues = false;
+    }
+
+    public Builder isMatchNoneOfValues(boolean matchNoneOfValues) {
+      value.matchNoneOfValues = matchNoneOfValues;
+      return this;
+    }
+
+    public Builder isMatchAny(boolean matchAny) {
+      value.matchAny = matchAny;
+      return this;
+    }
+
+    public Builder addValue(String value) {
+      buildingValues.add(Validate.notNull(value));
+      return this;
+    }
+
+    public Builder addValues(Collection<String> values) {
+      buildingValues.addAll(Validate.noNullElements(values));
+      return this;
+    }
+
+    public Builder addValues(String[] values) {
+      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;
+        value.values = new String[0];
+      }
+      value.calcHashes();
+      value.text = value.getParsedText();
+      return super.build();
+    }
+  }
 }

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

+package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
+
+import static de.unikoblenz.fgbks.base.utils.boundary.bicreater.BoundaryBiCreaterType.COMBINE;
+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 BiCreaterStringCombineTest {
+
+  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(COMBINE, sb2).get();
+    assertArrayEquals(new String[]{"a", "b"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.isMatchAny());
+
+    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(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());
+
+    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(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());
+
+    sb1 = StringBoundary.getBuilder().addValue("b").build();
+    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(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());
+
+    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("a").build();
+    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("b").build();
+    sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
+    assertArrayEquals(new String[]{}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertTrue(sbR.isMatchAny());
+
+    sb1 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("a").build();
+    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(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());
+
+    sb1 = StringBoundary.getBuilder().isMatchAny(true).build();
+    sb2 = StringBoundary.getBuilder().isMatchNoneOfValues(true).addValue("b").addValue("a").build();
+    sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
+    assertArrayEquals(new String[]{}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertTrue(sbR.isMatchAny());
+
+    sb1 = StringBoundary.getBuilder().isMatchAny(true).build();
+    sb2 = StringBoundary.getBuilder().isMatchAny(true).build();
+    sbR = (StringBoundary) sb1.createBi(COMBINE, sb2).get();
+    assertArrayEquals(new String[]{}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertTrue(sbR.isMatchAny());
+  }
+}

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

+package de.unikoblenz.fgbks.base.utils.boundary.creater;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+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 CreaterStringLowerTest {
+
+  @Test
+  public void testStringLower() {
+    StringBoundary sb = StringBoundary.getBuilder().addValue("a").build();
+    assertEquals("a", sb.getValues()[0]);
+    assertFalse(sb.isMatchAny());
+    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());
+  }
+}

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

+package de.unikoblenz.fgbks.base.utils.boundary.impl;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class StringBoundaryTest {
+
+  @Test
+  public void testBuilder() {
+    StringBoundary sb = StringBoundary.getBuilder().addValue("a").build();
+    Assertions.assertEquals("a", sb.getValues()[0]);
+    Assertions.assertFalse(sb.isMatchAny());
+    Assertions.assertFalse(sb.matchesNoneOfValues());
+    Assertions.assertEquals("\"a\"", sb.getText());
+
+    sb = StringBoundary.getBuilder().addValue("a").addValue("b").isMatchNoneOfValues(true).build();
+    Assertions.assertEquals("a", sb.getValues()[0]);
+    Assertions.assertFalse(sb.isMatchAny());
+    Assertions.assertTrue(sb.matchesNoneOfValues());
+    Assertions.assertEquals("not(\"a\",\"b\")", sb.getText());
+  }
+}