Merge branch 'develop' into feature-documentation

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/api/test/GreetingResource.java

-package de.unikoblenz.fgbks.api.test;
-
-import de.unikoblenz.fgbks.core.test.Synonyms;
-import javax.inject.Inject;
-import javax.ws.rs.Consumes;
-import javax.ws.rs.GET;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Path("/hello")
-public class GreetingResource {
-
-  private static Logger LOGGER = LoggerFactory.getLogger("test");
-
-  @Inject WordnetServiceX wordnetServiceX;
-
-  @GET
-  @Produces(MediaType.APPLICATION_JSON)
-  @Consumes(MediaType.TEXT_PLAIN)
-  @Path("/{word}")
-  public Response hello(@PathParam("word") String word) {
-    return Response.accepted(new Synonyms(wordnetServiceX.getNounsSynonyms(word))).build();
-  }
-
-  @GET
-  @Produces(MediaType.TEXT_PLAIN)
-  @Consumes(MediaType.TEXT_PLAIN)
-  @Path("/{word1}/{word2}")
-  public String hello(@PathParam("word1") String word1, @PathParam("word2") String word2) {
-    return Boolean.toString(wordnetServiceX.areNounsSynonyms(word1, word2));
-  }
-}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/api/test/TestApi.java

-package de.unikoblenz.fgbks.api.test;
-
-import de.unikoblenz.fgbks.core.dmn.utils.DmnService;
-import de.unikoblenz.fgbks.core.dmn.verification.DmnVerificationService;
-import javax.inject.Inject;
-import javax.ws.rs.Consumes;
-import javax.ws.rs.POST;
-import javax.ws.rs.Path;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Path("/builder")
-public class TestApi {
-
-  private static Logger LOGGER = LoggerFactory.getLogger(TestApi.class.getSimpleName());
-
-  @Inject protected DmnService dmnService;
-
-  @Inject protected DmnVerificationService dmnVerificationService;
-
-  @POST
-  @Produces(MediaType.APPLICATION_JSON)
-  @Consumes(MediaType.TEXT_XML)
-  public Response helloBuilder(String payload) {
-    return Response.accepted(dmnVerificationService.generate(payload)).build();
-  }
-}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/api/test/WordnetServiceX.java

-package de.unikoblenz.fgbks.api.test;
-
-import de.unikoblenz.fgbks.base.wordnet.WordnetService;
-import de.unikoblenz.fgbks.base.wordnet.WordnetServiceFunctions;
-import java.util.Set;
-import javax.enterprise.context.ApplicationScoped;
-
-@ApplicationScoped
-public class WordnetServiceX implements WordnetServiceFunctions {
-
-  private WordnetService wordnetService = WordnetService.getInstance();
-
-  @Override
-  public boolean areNounsSynonyms(String noun1, String noun2) {
-    return wordnetService.areNounsSynonyms(noun1, noun2);
-  }
-
-  @Override
-  public Set<String> getNounsSynonyms(String noun) {
-    return wordnetService.getNounsSynonyms(noun);
-  }
-}

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,80 @@ 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()) {
+      return Optional.of(StringBoundary.getBuilder().matchesAny(true).build());
+    }
+    if (b1.matchesAny() && !b2.matchesNoneOfValues()
+        || b2.matchesAny() && !b1.matchesNoneOfValues()) {
+      return Optional.of(
+          StringBoundary.getBuilder()
+              .addValues(b1.matchesAny() ? b2.getValues() : b1.getValues())
+              .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

 package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
 
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_EQUAL;
+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.Optional;
+import java.util.Set;
 
 public class BiCreaterStringLowerBounds extends AbstractBoundaryBiCreater<StringBoundary> {
 
@@ -22,6 +28,19 @@ public class BiCreaterStringLowerBounds extends AbstractBoundaryBiCreater<String
 
   @Override
   public Optional<StringBoundary> create(StringBoundary b1, StringBoundary b2) {
-    return Optional.empty();
+    if (b1.checkWith(IS_NOT_IN_CONTACT, b2) || b1.checkWith(IS_EQUAL, b2)) {
+      return Optional.empty();
+    }
+    if (b1.matchesAny() || b1.matchesNoneOfValues()) {
+      return Optional.of(
+          StringBoundary.getBuilder()
+              .addValues(b1.getValues())
+              .addValues(b2.getValues())
+              .matchesNoneOfValues(!b2.matchesNoneOfValues())
+              .build());
+    }
+    Set<String> values = new HashSet<>(Arrays.asList(b1.getValues()));
+    values.removeAll(Arrays.asList(b2.getValues()));
+    return Optional.of(StringBoundary.getBuilder().addValues(values).build());
   }
 }

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;
     }
@@ -44,13 +44,29 @@ public class CheckStringInContact extends AbstractBoundaryCheck<StringBoundary>
       return false;
     }
     // one is matching non values "not("a")"
-    if (b1h.length != b2h.length) {
-      return true;
+    if (b1.matchesNoneOfValues()) {
+      outer:
+      for (int i : b2h) {
+        for (int u : b1h) {
+          if (i == u) {
+            continue outer;
+          }
+        }
+        return true;
+      }
+      return false;
     }
-    for (int i = 0; i < b1h.length; i++) {
-      if (b1h[i] != b2h[i]) {
+    if (b2.matchesNoneOfValues()) {
+      outer:
+      for (int i : b1h) {
+        for (int u : b2h) {
+          if (i == u) {
+            continue outer;
+          }
+        }
         return true;
       }
+      return false;
     }
     return false;
   }

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/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/MissingRuleVerifier.java

@@ -100,12 +100,19 @@ public class MissingRuleVerifier extends AbstractVerifier {
       List<VDmnRuleChangeableImpl> missingRules) {
     // search the missing rules, which are in contact with the current rule
     List<VDmnRuleChangeableImpl> inContactRules = new LinkedList<>();
+    List<VDmnRuleChangeableImpl> inEqualRules = new LinkedList<>();
     for (VDmnRuleChangeableImpl missingRule : missingRules) {
       if (isInContact(missingRule, currentRule)) {
-        inContactRules.add(missingRule);
+        // dont add equal rules
+        if (isEqualRule(missingRule, currentRule)) {
+          inEqualRules.add(missingRule);
+        } else {
+          inContactRules.add(missingRule);
+        }
       }
     }
     // remove found rules from current missingRules
+    missingRules.removeAll(inEqualRules);
     missingRules.removeAll(inContactRules);
     // Build new missing rules from in contact rules
     List<VDmnRuleChangeableImpl> newMissingRules = new LinkedList<>();
@@ -114,7 +121,21 @@ public class MissingRuleVerifier extends AbstractVerifier {
     }
     // mergeRules(newMissingRules);
     missingRules.addAll(newMissingRules);
-    mergeRules(missingRules);
+    // mergeRules(missingRules);
+  }
+
+  private boolean isEqualRule(VDmnRule missingRule, VDmnRule currentRule) {
+    List<VDmnInputValue> inValsMissingRule = missingRule.getDmnInputValues();
+    List<VDmnInputValue> inValsCurrentRule = currentRule.getDmnInputValues();
+    for (int i = 0; i < inValsMissingRule.size(); i++) {
+      if (!inValsMissingRule
+          .get(i)
+          .getBoundary()
+          .checkWith(BoundaryCheckType.IS_EQUAL, inValsCurrentRule.get(i).getBoundary())) {
+        return false;
+      }
+    }
+    return true;
   }
 
   private List<VDmnRuleChangeableImpl> constructNewMissingRules(

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/test/Person.java

-package de.unikoblenz.fgbks.core.test;
-
-import de.unikoblenz.fgbks.base.domain.Name;
-import java.io.Serializable;
-import java.util.Objects;
-
-public class Person implements Serializable {
-
-  private Name name;
-
-  public Person(Name name) {
-    this.name = name;
-  }
-
-  public Name getName() {
-    return name;
-  }
-
-  public void setName(Name name) {
-    this.name = name;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    Person person = (Person) o;
-    return Objects.equals(name, person.name);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(name);
-  }
-}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/test/Synonyms.java

-package de.unikoblenz.fgbks.core.test;
-
-import java.io.Serializable;
-import java.util.Set;
-
-public class Synonyms implements Serializable {
-
-  private Set<String> synonyms;
-
-  public Synonyms(Set<String> synonyms) {
-    this.synonyms = synonyms;
-  }
-
-  public Set<String> getSynonyms() {
-    return synonyms;
-  }
-}

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[]{"a"}, sbR.getValues());
+    assertFalse(sbR.matchesNoneOfValues());
+    assertFalse(sbR.matchesAny());
+
+    sb1 = StringBoundary.getBuilder().addValue("a").build();
+    sb2 = StringBoundary.getBuilder().matchesAny(true).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().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());
+  }
+}