From e722deec08fe509f3e5a2b701c7e3260ee10aa66 Mon Sep 17 00:00:00 2001 From: Attila Ficsor Date: Mon, 7 Aug 2023 12:04:58 +0200 Subject: Update exploration strategies - Fix best first search algorithm - Improve efficiency of exploration adapter --- .../store/dse/DesignSpaceExplorationAdapter.java | 6 +- .../dse/DesignSpaceExplorationStoreAdapter.java | 18 +++++ .../java/tools/refinery/store/dse/Strategy.java | 4 +- .../DesignSpaceExplorationAdapterImpl.java | 92 ++++++++++++---------- .../DesignSpaceExplorationStoreAdapterImpl.java | 27 ++++--- .../store/dse/internal/TransformationRule.java | 16 +++- .../store/dse/strategy/BestFirstStrategy.java | 36 +++++++-- .../store/dse/strategy/DepthFirstStrategy.java | 20 ++++- .../refinery/store/dse/TransformationRuleTest.java | 18 ++--- 9 files changed, 161 insertions(+), 76 deletions(-) (limited to 'subprojects') diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java index 8963a496..c4aa97c2 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java @@ -38,7 +38,9 @@ public interface DesignSpaceExplorationAdapter extends ModelAdapter { public boolean backtrack(); - public Fitness calculateFitness(); + public boolean backtrack(String reason); + + public Fitness getFitness(); public void newSolution(); @@ -63,4 +65,6 @@ public interface DesignSpaceExplorationAdapter extends ModelAdapter { public void setRandom(Random random); public void setRandom(long seed); + + public List getSolutions(); } diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java index 186bfebb..0252748d 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java @@ -6,6 +6,24 @@ package tools.refinery.store.dse; import tools.refinery.store.adapter.ModelStoreAdapter; +import tools.refinery.store.dse.internal.TransformationRule; +import tools.refinery.store.dse.objectives.Objective; +import tools.refinery.store.model.Model; +import tools.refinery.store.query.dnf.RelationalQuery; + +import java.util.List; +import java.util.Set; public interface DesignSpaceExplorationStoreAdapter extends ModelStoreAdapter { + + @Override + DesignSpaceExplorationAdapter createModelAdapter(Model model); + + Set getTransformationSpecifications(); + + Set getGlobalConstraints(); + + List getObjectives(); + + Strategy getStrategy(); } diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java index e240f478..409fe8a6 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java @@ -7,7 +7,7 @@ package tools.refinery.store.dse; public interface Strategy { - public void initStrategy(DesignSpaceExplorationAdapter designSpaceExplorationAdapter); + void initStrategy(DesignSpaceExplorationAdapter designSpaceExplorationAdapter); - public void explore(); + void explore(); } diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java index b32e9696..4e5cc467 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java @@ -33,26 +33,28 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration private final Model model; private final ModelQueryAdapter queryEngine; private final DesignSpaceExplorationStoreAdapterImpl storeAdapter; - private final LinkedHashSet transformationRules; - private final LinkedHashSet globalConstraints; + private final Set transformationRules; + private final Set globalConstraints; private final List objectives; private final LinkedHashSet> globalConstraintResultSets = new LinkedHashSet<>(); private final Interpretation sizeInterpretation; private final Strategy strategy; private ObjectiveComparatorHelper objectiveComparatorHelper; - private List trajectory = new LinkedList<>(); + private List trajectory = new ArrayList<>(); + private Map parents = new HashMap<>(); private Fitness lastFitness; - private final LinkedHashSet solutions = new LinkedHashSet<>(); - private Map> statesAndUntraversedActivations; - private Map> statesAndTraversedActivations; + private final List solutions = new ArrayList<>(); + private Map> statesAndTraversedActivations; private Random random = new Random(); private boolean isNewState = false; private final boolean isVisualizationEnabled; private final ModelVisualizerAdapter modelVisualizerAdapter; + private final Map fitnessCache = new HashMap<>(); + public List getTrajectory() { - return new LinkedList<>(trajectory); + return new ArrayList<>(trajectory); } public DesignSpaceExplorationAdapterImpl(Model model, DesignSpaceExplorationStoreAdapterImpl storeAdapter) { @@ -72,7 +74,6 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration } objectives = storeAdapter.getObjectives(); - statesAndUntraversedActivations = new HashMap<>(); statesAndTraversedActivations = new HashMap<>(); strategy = storeAdapter.getStrategy(); modelVisualizerAdapter = model.tryGetAdapter(ModelVisualizerAdapter.class).orElse(null); @@ -91,11 +92,9 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration } @Override - public LinkedHashSet explore() { + public List explore() { var state = model.commit(); trajectory.add(state); - statesAndUntraversedActivations.put(state, getAllActivations()); - statesAndTraversedActivations.put(state, new LinkedHashSet<>()); strategy.initStrategy(this); strategy.explore(); return solutions; @@ -137,14 +136,22 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration @Override public boolean backtrack() { + return backtrack(""); + } + @Override + public boolean backtrack(String reason) { if (trajectory.size() < 2) { return false; } + var currentState = model.getState(); + if (!parents.containsKey(currentState)) { + return false; + } if (isVisualizationEnabled) { modelVisualizerAdapter.addTransition(trajectory.get(trajectory.size() - 1), - trajectory.get(trajectory.size() - 2), "backtrack"); + trajectory.get(trajectory.size() - 2), "backtrack(" + reason + ")"); } - model.restore(trajectory.get(trajectory.size() - 2)); + model.restore(parents.get(model.getState())); trajectory.remove(trajectory.size() - 1); return true; } @@ -156,7 +163,7 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration // modelVisualizerAdapter.addTransition(this.trajectory.get(trajectory.size() - 1), // trajectory.get(trajectory.size() - 1), "restore"); // } - this.trajectory = trajectory; + this.trajectory = new ArrayList<>(trajectory); } @@ -171,7 +178,18 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration } @Override - public Fitness calculateFitness() { + public List getSolutions() { + return solutions; + } + + @Override + public Fitness getFitness() { + var result = fitnessCache.computeIfAbsent(model.getState(), s -> calculateFitness()); + lastFitness = result; + return result; + } + + private Fitness calculateFitness() { Fitness result = new Fitness(); boolean satisfiesHardObjectives = true; for (Objective objective : objectives) { @@ -203,15 +221,19 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration } public LinkedHashSet getUntraversedActivations() { -// return statesAndUntraversedActivations.get(model.getState()); - LinkedHashSet untraversedActivations = new LinkedHashSet<>(); - for (Activation activation : getAllActivations()) { - if (!statesAndTraversedActivations.get(model.getState()).contains(activation)) { - untraversedActivations.add(activation); + var traversedActivations = statesAndTraversedActivations.get(model.getState()); + if (traversedActivations == null) { + return new LinkedHashSet<>(getAllActivations()); + } + else { + LinkedHashSet untraversedActivations = new LinkedHashSet<>(); + for (Activation activation : getAllActivations()) { + if (!traversedActivations.contains(activation)) { + untraversedActivations.add(activation); + } } + return untraversedActivations; } - - return untraversedActivations; } @Override @@ -220,26 +242,20 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration return false; } var previousState = model.getState(); - if (!statesAndUntraversedActivations.get(previousState).contains(activation)) { -// TODO: throw exception? - return false; - } if (!activation.fire()) { return false; } - statesAndUntraversedActivations.get(previousState).remove(activation); - statesAndTraversedActivations.get(previousState).add(activation); + statesAndTraversedActivations.computeIfAbsent(previousState, s -> new ArrayList<>()).add(activation); var newState = model.commit(); trajectory.add(newState); - isNewState = !statesAndUntraversedActivations.containsKey(newState); - statesAndUntraversedActivations.put(newState, getAllActivations()); - statesAndTraversedActivations.put(newState, new LinkedHashSet<>()); + parents.put(newState, previousState); + isNewState = !statesAndTraversedActivations.containsKey(newState); if (isVisualizationEnabled) { if (isNewState) { modelVisualizerAdapter.addState(newState); } - modelVisualizerAdapter.addTransition(trajectory.get(trajectory.size() - 2), - trajectory.get(trajectory.size() - 1), activation.transformationRule().getName(), + // TODO: Change to this: + modelVisualizerAdapter.addTransition(previousState, newState, activation.transformationRule().getName(), activation.activation()); } return true; @@ -266,10 +282,10 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration return trajectory.contains(model.getState()); } - public LinkedHashSet getAllActivations() { - LinkedHashSet result = new LinkedHashSet<>(); + public List getAllActivations() { + List result = new LinkedList<>(); for (var rule : transformationRules) { - result.addAll(rule.getAllActivations()); + result.addAll(rule.getAllActivationsAsList()); } return result; } @@ -279,10 +295,6 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration return !isNewState; } - public Fitness getLastFitness() { - return lastFitness; - } - public ObjectiveComparatorHelper getObjectiveComparatorHelper() { if (objectiveComparatorHelper == null) { objectiveComparatorHelper = new ObjectiveComparatorHelper(objectives); diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java index 09925ae7..fea39886 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java @@ -5,27 +5,26 @@ */ package tools.refinery.store.dse.internal; -import tools.refinery.store.adapter.ModelAdapter; -import tools.refinery.store.model.Model; -import tools.refinery.store.model.ModelStore; -import tools.refinery.store.query.dnf.RelationalQuery; import tools.refinery.store.dse.DesignSpaceExplorationStoreAdapter; import tools.refinery.store.dse.Strategy; import tools.refinery.store.dse.objectives.Objective; +import tools.refinery.store.model.Model; +import tools.refinery.store.model.ModelStore; +import tools.refinery.store.query.dnf.RelationalQuery; -import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplorationStoreAdapter { private final ModelStore store; - private final LinkedHashSet transformationSpecifications; - private final LinkedHashSet globalConstraints; + private final Set transformationSpecifications; + private final Set globalConstraints; private final List objectives; private final Strategy strategy; public DesignSpaceExplorationStoreAdapterImpl(ModelStore store, - LinkedHashSet transformationSpecifications, - LinkedHashSet globalConstraints, + Set transformationSpecifications, + Set globalConstraints, List objectives, Strategy strategy) { this.store = store; this.transformationSpecifications = transformationSpecifications; @@ -40,22 +39,26 @@ public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplor } @Override - public ModelAdapter createModelAdapter(Model model) { + public DesignSpaceExplorationAdapterImpl createModelAdapter(Model model) { return new DesignSpaceExplorationAdapterImpl(model, this); } - public LinkedHashSet getTransformationSpecifications() { + @Override + public Set getTransformationSpecifications() { return transformationSpecifications; } - public LinkedHashSet getGlobalConstraints() { + @Override + public Set getGlobalConstraints() { return globalConstraints; } + @Override public List getObjectives() { return objectives; } + @Override public Strategy getStrategy() { return strategy; } diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java index 015d4815..8123c0d6 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java @@ -14,8 +14,7 @@ import tools.refinery.store.query.resultset.OrderedResultSet; import tools.refinery.store.query.resultset.ResultSet; import tools.refinery.store.tuple.Tuple; -import java.util.LinkedHashSet; -import java.util.Random; +import java.util.*; public class TransformationRule { @@ -66,11 +65,11 @@ public class TransformationRule { return precondition; } - public ResultSet getAllActivationsAsSets() { + public ResultSet getAllActivationsAsResultSet() { return activations; } - public LinkedHashSet getAllActivations() { + public Set getAllActivations() { var result = new LinkedHashSet(); var cursor = activations.getAll(); while (cursor.move()) { @@ -79,6 +78,15 @@ public class TransformationRule { return result; } + public List getAllActivationsAsList() { + var result = new ArrayList(); + var cursor = activations.getAll(); + while (cursor.move()) { + result.add(new Activation(this, cursor.getKey())); + } + return result; + } + public Activation getRandomActivation() { return new Activation(this, activations.getKey(random.nextInt(activations.size()))); } diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java index 8648864c..57f86401 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java @@ -26,6 +26,7 @@ public class BestFirstStrategy implements Strategy { private DesignSpaceExplorationAdapter dseAdapter; private int maxDepth; + private int maxSolutions; private boolean backTrackIfSolution = true; private boolean onlyBetterFirst = false; @@ -54,11 +55,20 @@ public class BestFirstStrategy implements Strategy { } public BestFirstStrategy(int maxDepth) { + this(maxDepth, -1); + } + + public BestFirstStrategy(int maxDepth, int maxSolutions) { if (maxDepth < 0) { this.maxDepth = Integer.MAX_VALUE; } else { this.maxDepth = maxDepth; } + if (maxSolutions < 0) { + this.maxSolutions = Integer.MAX_VALUE; + } else { + this.maxSolutions = maxSolutions; + } } public BestFirstStrategy continueIfHardObjectivesFulfilled() { @@ -76,12 +86,15 @@ public class BestFirstStrategy implements Strategy { this.dseAdapter = designSpaceExplorationAdapter; final ObjectiveComparatorHelper objectiveComparatorHelper = dseAdapter.getObjectiveComparatorHelper(); - trajectoriesToExplore = new PriorityQueue(11, + trajectoriesToExplore = new PriorityQueue<>(11, (o1, o2) -> objectiveComparatorHelper.compare(o2.fitness, o1.fitness)); } @Override public void explore() { + if (maxSolutions == 0) { + return; + } final ObjectiveComparatorHelper objectiveComparatorHelper = dseAdapter.getObjectiveComparatorHelper(); boolean globalConstraintsAreSatisfied = dseAdapter.checkGlobalConstraints(); @@ -90,7 +103,7 @@ public class BestFirstStrategy implements Strategy { return; } - final Fitness firstFitness = dseAdapter.calculateFitness(); + final Fitness firstFitness = dseAdapter.getFitness(); if (firstFitness.isSatisfiesHardObjectives()) { dseAdapter.newSolution(); // "First state is a solution. Terminate."); @@ -103,9 +116,16 @@ public class BestFirstStrategy implements Strategy { return; } - final List firstTrajectory = dseAdapter.getTrajectory(); - TrajectoryWithFitness currentTrajectoryWithFitness = new TrajectoryWithFitness(firstTrajectory, firstFitness); - trajectoriesToExplore.add(currentTrajectoryWithFitness); +// final List firstTrajectory = dseAdapter.getTrajectory(); + +// TrajectoryWithFitness currentTrajectoryWithFitness = new TrajectoryWithFitness(dseAdapter.getTrajectory(), +// firstFitness); +// trajectoriesToExplore.add(currentTrajectoryWithFitness); + + + var firstTrajectoryWithFitness = new TrajectoryWithFitness(dseAdapter.getTrajectory(), firstFitness); + trajectoriesToExplore.add(firstTrajectoryWithFitness); + TrajectoryWithFitness currentTrajectoryWithFitness = null; mainLoop: while (true) { @@ -145,9 +165,13 @@ public class BestFirstStrategy implements Strategy { // "Global constraint is not satisfied."); dseAdapter.backtrack(); } else { - final Fitness nextFitness = dseAdapter.calculateFitness(); + final Fitness nextFitness = dseAdapter.getFitness(); if (nextFitness.isSatisfiesHardObjectives()) { dseAdapter.newSolution(); + var solutions = dseAdapter.getSolutions().size(); + if (solutions >= maxSolutions) { + return; + } // "Found a solution."); if (backTrackIfSolution) { dseAdapter.backtrack(); diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java index 1405789b..f4a0747a 100644 --- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java +++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java @@ -21,6 +21,7 @@ public class DepthFirstStrategy implements Strategy { private DesignSpaceExplorationAdapter dseAdapter; private int maxDepth; + private int maxSolutions; private boolean backTrackIfSolution = true; public DepthFirstStrategy() { @@ -28,11 +29,20 @@ public class DepthFirstStrategy implements Strategy { } public DepthFirstStrategy(int maxDepth) { + this(maxDepth, -1); + } + + public DepthFirstStrategy(int maxDepth, int maxSolutions) { if (maxDepth < 0) { this.maxDepth = Integer.MAX_VALUE; } else { this.maxDepth = maxDepth; } + if (maxSolutions < 0) { + this.maxSolutions = Integer.MAX_VALUE; + } else { + this.maxSolutions = maxSolutions; + } } public DepthFirstStrategy continueIfHardObjectivesFulfilled() { @@ -47,6 +57,9 @@ public class DepthFirstStrategy implements Strategy { @Override public void explore() { + if (maxSolutions == 0) { + return; + } mainloop: while (true) { var globalConstraintsAreSatisfied = dseAdapter.checkGlobalConstraints(); if (!globalConstraintsAreSatisfied) { @@ -61,9 +74,13 @@ public class DepthFirstStrategy implements Strategy { } } - Fitness fitness = dseAdapter.calculateFitness(); + Fitness fitness = dseAdapter.getFitness(); if (fitness.isSatisfiesHardObjectives()) { dseAdapter.newSolution(); + var solutions = dseAdapter.getSolutions().size(); + if (solutions >= maxSolutions) { + return; + } if (backTrackIfSolution) { var isSuccessfulUndo = dseAdapter.backtrack(); if (!isSuccessfulUndo) { @@ -76,7 +93,6 @@ public class DepthFirstStrategy implements Strategy { } } - var depth = dseAdapter.getDepth(); if (dseAdapter.getDepth() >= maxDepth) { var isSuccessfulUndo = dseAdapter.backtrack(); if (!isSuccessfulUndo) { diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java index 312bcebd..f57f68ef 100644 --- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java +++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java @@ -137,8 +137,8 @@ public class TransformationRuleTest { queryEngine.flushChanges(); - var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsSets(); - var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsSets(); + var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsResultSet(); + var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsResultSet(); assertResults(Map.of( Tuple.of(newClass1Id, newFieldId), true, @@ -236,12 +236,12 @@ public class TransformationRuleTest { assertResults(Map.of( Tuple.of(newModelId, newClass1Id), true, Tuple.of(newModelId, newClass2Id), true - ), deleteEmptyClassRule0.getAllActivationsAsSets()); + ), deleteEmptyClassRule0.getAllActivationsAsResultSet()); assertResults(Map.of( Tuple.of(newModelId, newClass1Id), true, Tuple.of(newModelId, newClass2Id), true - ), deleteEmptyClassRule1.getAllActivationsAsSets()); + ), deleteEmptyClassRule1.getAllActivationsAsResultSet()); assertEquals(Tuple.of(newModelId, newClass2Id), activation0); assertEquals(Tuple.of(newModelId, newClass1Id), activation1); @@ -312,7 +312,7 @@ public class TransformationRuleTest { assertResults(Map.of( Tuple.of(newModelId, newClass1Id), true, Tuple.of(newModelId, newClass2Id), true - ), deleteEmptyClassRule.getAllActivationsAsSets()); + ), deleteEmptyClassRule.getAllActivationsAsResultSet()); deleteEmptyClassRule.fireActivation(Tuple.of(0, 1)); @@ -320,7 +320,7 @@ public class TransformationRuleTest { assertResults(Map.of( Tuple.of(newModelId, newClass1Id), false, Tuple.of(newModelId, newClass2Id), true - ), deleteEmptyClassRule.getAllActivationsAsSets()); + ), deleteEmptyClassRule.getAllActivationsAsResultSet()); } @Test @@ -388,21 +388,21 @@ public class TransformationRuleTest { assertResults(Map.of( Tuple.of(newModelId, newClass1Id), true, Tuple.of(newModelId, newClass2Id), true - ), deleteEmptyClassRule.getAllActivationsAsSets()); + ), deleteEmptyClassRule.getAllActivationsAsResultSet()); deleteEmptyClassRule.fireRandomActivation(); assertResults(Map.of( Tuple.of(newModelId, newClass1Id), true, Tuple.of(newModelId, newClass2Id), false - ), deleteEmptyClassRule.getAllActivationsAsSets()); + ), deleteEmptyClassRule.getAllActivationsAsResultSet()); deleteEmptyClassRule.fireRandomActivation(); assertResults(Map.of( Tuple.of(newModelId, newClass1Id), false, Tuple.of(newModelId, newClass2Id), false - ), deleteEmptyClassRule.getAllActivationsAsSets()); + ), deleteEmptyClassRule.getAllActivationsAsResultSet()); } } -- cgit v1.2.3-54-g00ecf