Test place predicates and transformers

Author: VikiPeeva

src/org/processmining/placebasedlpmdiscovery/model/Place.java

@@ -39,7 +39,8 @@ public Place(String id) {
      * Create a place from its string representation. The string representation differentiates input and output transitions
      * using a | character. For example, the string "a, b | c, d" represents a place with input transitions a and b,
      * and output transitions c and d. Each transition is represented by its label and is assumed to be visible.
-     * Transitions are separated by commas. Whitespace around labels and the | character is ignored.
+     * Transitions are separated by commas. Whitespace around labels and the | character is ignored. It is possible
+     * to create places with empty input or output transition set, e.g., "|", "| a, b" or "a, b |".
      * @param stringRepresentation the string representation of the place
      * @return a Place object corresponding to the string representation
      * @throws IllegalArgumentException if the string representation is invalid

src/org/processmining/placebasedlpmdiscovery/placechooser/MainPlaceChooser.java

@@ -3,7 +3,7 @@
 import org.deckfour.xes.model.XLog;
 import org.processmining.placebasedlpmdiscovery.analysis.analyzers.loganalyzer.LEFRMatrix;
 import org.processmining.placebasedlpmdiscovery.model.Place;
-import org.processmining.placebasedlpmdiscovery.placechooser.placepredicates.MostKArcsPredicate;
+import org.processmining.placebasedlpmdiscovery.placechooser.placepredicates.MostKArcsPlacePredicate;
 import org.processmining.placebasedlpmdiscovery.placechooser.placepredicates.NonEmptyIOTransitionSetPlacePredicate;
 import org.processmining.placebasedlpmdiscovery.placechooser.placepredicates.NonSelfLoopPlacePredicate;
 import org.processmining.placebasedlpmdiscovery.placechooser.placerankconverters.RankedPlace;
@@ -40,7 +40,7 @@ public Set<Place> choose(Set<Place> places, int count) {
                 .map(new PassageUsagePlaceTransformer(LogUtils.getFollowRelations(log, placeChooserParameters.getFollowRelationsLimit()))) // TODO: this might be duplicate work, since the lefr should already contain it
                 .filter(new NonSelfLoopPlacePredicate())
                 .filter(new NonEmptyIOTransitionSetPlacePredicate())
-                .filter(new MostKArcsPredicate(5))
+                .filter(new MostKArcsPlacePredicate(5))
                 .map(p -> new RankedPlace(p, new TransitionCountPlaceRankConverter().convert(p) /*, new TotalPassageCoveragePlaceRankConverter(lefr).convert(p) */))
                 .sorted(new RankedPlaceComparator())
                 .map(RankedPlace::getPlace)

src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/AndPredicate.java renamed to src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/AndPlacePredicate.java

@@ -6,11 +6,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-public class AndPredicate implements PlacePredicate {
+public class AndPlacePredicate implements PlacePredicate {
 
     Collection<PlacePredicate> predicates;
 
-    public AndPredicate (PlacePredicate ... predicates) {
+    public AndPlacePredicate(PlacePredicate ... predicates) {
         this.predicates = new ArrayList<>();
         this.predicates.addAll(Arrays.asList(predicates));
     }

src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/MostKArcsPredicate.java renamed to src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/MostKArcsPlacePredicate.java

@@ -2,11 +2,14 @@
 
 import org.processmining.placebasedlpmdiscovery.model.Place;
 
-public class MostKArcsPredicate implements PlacePredicate {
+public class MostKArcsPlacePredicate implements PlacePredicate {
 
     private final int k;
 
-    public MostKArcsPredicate(int k) {
+    public MostKArcsPlacePredicate(int k) {
+        if (k < 0) {
+            throw new IllegalArgumentException("k must be a non-negative integer.");
+        }
         this.k = k;
     }
 

src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/NonEmptyIOTransitionSetPlacePredicate.java

@@ -5,12 +5,12 @@
 public class NonEmptyIOTransitionSetPlacePredicate implements PlacePredicate {
 
     /**
-     * Checks for empty input or output transition set
+     * Checks for an empty input or output transition set
      * @param place that we want to check for filtering
      * @return false when the input or output transition set is empty, true otherwise
      */
     @Override
     public boolean testPlace(Place place) {
-        return place.getInputTransitions().size() > 0 && place.getOutputTransitions().size() > 0;
+        return !place.getInputTransitions().isEmpty() && !place.getOutputTransitions().isEmpty();
     }
 }

src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/OrPredicate.java renamed to src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/OrPlacePredicate.java

@@ -6,10 +6,10 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-public class OrPredicate implements PlacePredicate {
+public class OrPlacePredicate implements PlacePredicate {
     Collection<PlacePredicate> predicates;
 
-    public OrPredicate (PlacePredicate ... predicates) {
+    public OrPlacePredicate(PlacePredicate ... predicates) {
         this.predicates = new ArrayList<>();
         this.predicates.addAll(Arrays.asList(predicates));
     }

src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/PlacePredicateFactory.java

@@ -26,9 +26,9 @@ private PlacePredicate getPredicate(ConfigElement el) {
 
     private PlacePredicate getComplexPredicate(PlacePredicateType type, PlacePredicate... subPredicates) {
         if (type == PlacePredicateType.AND) {
-            return new AndPredicate(subPredicates);
+            return new AndPlacePredicate(subPredicates);
         } else if (type == PlacePredicateType.OR) {
-            return new OrPredicate(subPredicates);
+            return new OrPlacePredicate(subPredicates);
         } else {
             throw new IllegalArgumentException("The type: " + type + " is not complex or it doesn't exist.");
         }

src/org/processmining/placebasedlpmdiscovery/placechooser/placetransformers/PassageUsagePlaceTransformer.java

@@ -3,75 +3,42 @@
 import org.apache.commons.math3.util.Pair;
 import org.processmining.placebasedlpmdiscovery.model.Place;
 import org.processmining.placebasedlpmdiscovery.model.Transition;
-import org.processmining.placebasedlpmdiscovery.utils.PlaceUtils;
 
-import java.util.HashSet;
-import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
 public class PassageUsagePlaceTransformer implements PlaceTransformer {
 
-    private final Set<Pair<String, String>> eventuallyFollowedActivities;
+    private final Set<Pair<String, String>> locallyOccurringPassages;
 
-    public PassageUsagePlaceTransformer(Set<Pair<String, String>> eventuallyFollowedActivities) {
-        this.eventuallyFollowedActivities = eventuallyFollowedActivities;
+    public PassageUsagePlaceTransformer(Set<Pair<String, String>> locallyOccurringPassages) {
+        this.locallyOccurringPassages = locallyOccurringPassages;
     }
 
     @Override
     public Place adapt(Place place) {
-        // Transitions to be removed
-        Set<String> inTransitionsToBeRemoved = new HashSet<>();
-        Set<String> outTransitionsToBeRemoved = new HashSet<>();
-
-        // get all pairs of input-output transition labels
-        Set<Pair<String, String>> placeInOutPair = PlaceUtils.getVisibleInoutPairsInPlace(place);
-        // keep only the pairs that are not happening in the given window
-        placeInOutPair.removeAll(eventuallyFollowedActivities);
-        // extract all labels that appear as input in the set of uncovered input-output transition pairs
-        Set<String> inputs = placeInOutPair.stream().map(Pair::getKey).collect(Collectors.toSet());
-        // map every input label with which output labels doesn't appear
-        Map<String, Set<String>> forwardMapping = inputs
-                .stream()
-                .collect(Collectors.toMap(
-                        x -> x,
-                        x -> placeInOutPair
-                                .stream()
-                                .filter(p -> p.getKey().equals(x))
-                                .map(Pair::getValue)
-                                .collect(Collectors.toSet())));
-        // mark all input transitions which don't happen with any of the output transitions
-        for (String inTr : forwardMapping.keySet()) {
-            if (place.getOutputTransitions().size() > 0 &&
-                    place.getOutputTransitions().stream().map(Transition::getLabel).collect(Collectors.toSet())
-                            .equals(forwardMapping.get(inTr)))
-                inTransitionsToBeRemoved.add(inTr);
-        }
-        // extract all labels that appear as output in the set of uncovered input-output transition pairs
-        Set<String> outputs = placeInOutPair.stream().map(Pair::getValue).collect(Collectors.toSet());
-        // map every output label with which input labels doesn't appear
-        Map<String, Set<String>> backwardMapping = outputs
-                .stream()
-                .collect(Collectors.toMap(
-                        x -> x,
-                        x -> placeInOutPair
-                                .stream()
-                                .filter(p -> p.getValue().equals(x))
-                                .map(Pair::getKey)
-                                .collect(Collectors.toSet())));
-        // mark all output transitions which don't happen with any of the input transitions
-        for (String outTr : backwardMapping.keySet()) {
-            if (place.getInputTransitions().size() > 0 &&
-                    place.getInputTransitions().stream().map(Transition::getLabel).collect(Collectors.toSet())
-                            .equals(backwardMapping.get(outTr)))
-                outTransitionsToBeRemoved.add(outTr);
-        }
-
-        // remove the transitions from the place
-        for (String label : inTransitionsToBeRemoved)
-            place.removeTransitions(label, true);
-        for (String label : outTransitionsToBeRemoved)
-            place.removeTransitions(label, false);
+        // used input transitions given the proximity
+        Set<String> usedInputTransitionLabels =
+                locallyOccurringPassages.stream().map(Pair::getKey).collect(Collectors.toSet());
+        // used output transitions given the proximity
+        Set<String> usedOutputTransitionLabels =
+                locallyOccurringPassages.stream().map(Pair::getValue).collect(Collectors.toSet());
+
+        // unused input transition labels
+        Set<String> unusedInputTransitionLabels = place.getInputTransitions().stream()
+                .map(Transition::getLabel)
+                .filter(label -> !usedInputTransitionLabels.contains(label))
+                .collect(Collectors.toSet());
+        // unused output transition labels
+        Set<String> unusedOutputTransitionLabels = place.getOutputTransitions().stream()
+                .map(Transition::getLabel)
+                .filter(label -> !usedOutputTransitionLabels.contains(label))
+                .collect(Collectors.toSet());
+
+        // remove unused input transitions
+        unusedInputTransitionLabels.forEach(label -> place.removeTransitions(label, true));
+        // remove unused output transitions
+        unusedOutputTransitionLabels.forEach(label -> place.removeTransitions(label, false));
 
         return place;
     }

tests/src/org/processmining/placebasedlpmdiscovery/model/PlaceTest.java

@@ -163,6 +163,24 @@ public void givenTwoInOneOutSingleLetter_whenFrom_thenPlaceWithTwoInOneOut() {
                 .containsExactly(new Transition("c", false));
     }
 
+    @Test
+    public void givenNoInNoOut_whenFrom_thenPlaceWithNoInNoOut() {
+        // given
+        String placeDescriptionEmptySpaces = "   |    ";
+        String placeDescriptionNoSpaces = "|";
+
+        // when
+        Place placeActualEmptySpaces = Place.from(placeDescriptionEmptySpaces);
+        Place placeActualNoSpaces = Place.from(placeDescriptionNoSpaces);
+
+        // then
+        Assert.assertEquals(0, placeActualEmptySpaces.getInputTransitions().size());
+        Assert.assertEquals(0, placeActualEmptySpaces.getOutputTransitions().size());
+
+        Assert.assertEquals(0, placeActualNoSpaces.getInputTransitions().size());
+        Assert.assertEquals(0, placeActualNoSpaces.getOutputTransitions().size());
+    }
+
     @Test
     public void givenOneInNoOutSingleLetter_whenFrom_thenPlaceWithOneInNoOut() {
         // given

tests/src/org/processmining/placebasedlpmdiscovery/placechooser/placepredicates/AndPlacePredicateTest.java

@@ -0,0 +1,47 @@
+package src.org.processmining.placebasedlpmdiscovery.placechooser.placepredicates;
+
+import org.junit.Test;
+import org.processmining.placebasedlpmdiscovery.model.Place;
+import org.processmining.placebasedlpmdiscovery.placechooser.placepredicates.AndPlacePredicate;
+
+public class AndPlacePredicateTest {
+
+    @Test
+    public void givenAllTruePredicates_whenTestPlace_thenReturnsTrue() {
+        // given
+        AndPlacePredicate andPredicate = new AndPlacePredicate((p) -> true, (p) -> true, (p) -> true);
+        Place mockPlace = Place.from("a | b");
+
+        // when
+        boolean actual = andPredicate.testPlace(mockPlace);
+
+        // then
+        assert actual;
+    }
+
+    @Test
+    public void givenOneFalsePredicate_whenTestPlace_thenReturnsFalse() {
+        // given
+        AndPlacePredicate andPredicate = new AndPlacePredicate((p) -> true, (p) -> false, (p) -> true);
+        Place mockPlace = Place.from("a | b");
+
+        // when
+        boolean actual = andPredicate.testPlace(mockPlace);
+
+        // then
+        assert !actual;
+    }
+
+    @Test
+    public void givenAllFalsePredicates_whenTestPlace_thenReturnsFalse() {
+        // given
+        AndPlacePredicate andPredicate = new AndPlacePredicate((p) -> false, (p) -> false, (p) -> false);
+        Place mockPlace = Place.from("a | b");
+
+        // when
+        boolean actual = andPredicate.testPlace(mockPlace);
+
+        // then
+        assert !actual;
+    }
+}