4 files changed, 202 insertions, 52 deletions

diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
index 4bdb05ec..225de32e 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
@@ -5,7 +5,9 @@
  */
 package tools.refinery.store.dse;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.dse.objectives.AlwaysSatisfiedRandomHardObjective;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.query.dnf.Query;
@@ -25,7 +27,7 @@ import java.util.List;
 
 import static tools.refinery.store.query.literal.Literals.not;
 
-public class CRAExamplesTest {
+class CRAExamplesTest {
         private static final Symbol<String> name = Symbol.of("Name", 1, String.class);
 
 //      private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
@@ -180,6 +182,7 @@ public class CRAExamplesTest {
                         });
 
         @Test
+        @Disabled("This test is only for debugging purposes")
         void craTest() {
                 var store = ModelStore.builder()
                                 .symbols(classElement, encapsulates, classes, features, attribute, method, dataDependency,
@@ -188,11 +191,18 @@ public class CRAExamplesTest {
                                                 .queries(feature, assignFeaturePreconditionHelper, assignFeaturePrecondition,
                                                                 deleteEmptyClassPrecondition, createClassPreconditionHelper, createClassPrecondition,
                                                                 moveFeaturePrecondition))
-                                .with(ModelVisualizerAdapter.builder())
+                                .with(ModelVisualizerAdapter.builder()
+                                                .withOutputpath("test_output")
+                                                .withFormat(FileFormat.DOT)
+                                                .withFormat(FileFormat.SVG)
+                                                .saveStates()
+                                                .saveDesignSpace()
+                                )
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(assignFeatureRule, deleteEmptyClassRule, createClassRule, moveFeatureRule)
-//                                              .strategy(new DepthFirstStrategy(3).continueIfHardObjectivesFulfilled()
-                                                .strategy(new BestFirstStrategy(6).continueIfHardObjectivesFulfilled()
+                                                .objectives(new AlwaysSatisfiedRandomHardObjective())
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(3).continueIfHardObjectivesFulfilled()
+                                                .strategy(new BestFirstStrategy().withDepthLimit(6).continueIfHardObjectivesFulfilled()
 //                                                              .goOnOnlyIfFitnessIsBetter()
                                                 ))
                                 .build();
@@ -271,9 +281,6 @@ public class CRAExamplesTest {
 
                 var states = dseAdapter.explore();
                 System.out.println("states size: " + states.size());
-                System.out.println("states: " + states);
-                var visualizer = model.getAdapter(ModelVisualizerAdapter.class);
-                visualizer.renderDesignSpace("test_output", FileFormat.SVG);
         }
 
 }
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
index 101a5362..c6da896c 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
@@ -5,7 +5,9 @@
  */
 package tools.refinery.store.dse;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.dse.objectives.AlwaysSatisfiedRandomHardObjective;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.query.dnf.Query;
@@ -20,7 +22,7 @@ import tools.refinery.store.tuple.Tuple;
 import tools.refinery.visualization.ModelVisualizerAdapter;
 import tools.refinery.visualization.internal.FileFormat;
 
-public class DebugTest {
+class DebugTest {
         private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
         private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
         private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
@@ -41,6 +43,7 @@ public class DebugTest {
 
 
         @Test
+        @Disabled("This test is only for debugging purposes")
         void BFSTest() {
                 var createClassPrecondition = Query.of("CreateClassPrecondition",
                                 (builder, model) -> builder.clause(
@@ -90,11 +93,18 @@ public class DebugTest {
                                 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(createClassPrecondition, createFeaturePrecondition))
-                                .with(ModelVisualizerAdapter.builder())
+                                .with(ModelVisualizerAdapter.builder()
+                                                .withOutputpath("test_output")
+                                                .withFormat(FileFormat.DOT)
+                                                .withFormat(FileFormat.SVG)
+                                                .saveStates()
+                                                .saveDesignSpace()
+                                )
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule, createFeatureRule)
-                                                .strategy(new DepthFirstStrategy(4).continueIfHardObjectivesFulfilled()
-//                                              .strategy(new BestFirstStrategy(4).continueIfHardObjectivesFulfilled()
+                                                .objectives(new AlwaysSatisfiedRandomHardObjective())
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
+//                                              .strategy(new BestFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
 //                                                              .goOnOnlyIfFitnessIsBetter()
                                                 ))
                                 .build();
@@ -113,10 +123,7 @@ public class DebugTest {
 
 
                 var states = dseAdapter.explore();
-                var visualizer = model.getAdapter(ModelVisualizerAdapter.class);
-                visualizer.renderDesignSpace("test_output", FileFormat.SVG);
                 System.out.println("states size: " + states.size());
-                System.out.println("states: " + states);
 
         }
 }
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
index f4644407..91e33f4a 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
@@ -17,11 +17,10 @@ import tools.refinery.store.query.view.AnySymbolView;
 import tools.refinery.store.query.view.KeyOnlyView;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
-import tools.refinery.visualization.ModelVisualizerAdapter;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-public class DesignSpaceExplorationTest {
+class DesignSpaceExplorationTest {
 //      private static final Symbol<Boolean> namedElement = Symbol.of("NamedElement", 1);
 //      private static final Symbol<Boolean> attribute = Symbol.of("Attribute", 1);
 //      private static final Symbol<Boolean> method = Symbol.of("Method", 1);
@@ -50,7 +49,8 @@ public class DesignSpaceExplorationTest {
         void createObjectTest() {
                 var store = ModelStore.builder()
                                 .with(ViatraModelQueryAdapter.builder())
-                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(0)))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -78,7 +78,8 @@ public class DesignSpaceExplorationTest {
         void deleteMiddleObjectTest() {
                 var store = ModelStore.builder()
                                 .with(ViatraModelQueryAdapter.builder())
-                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy()))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -118,9 +119,8 @@ public class DesignSpaceExplorationTest {
                 var store = ModelStore.builder()
                                 .symbols(classModel)
                                 .with(ViatraModelQueryAdapter.builder())
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
-                                                .strategy(new DepthFirstStrategy(0)))
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(0)))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -158,10 +158,9 @@ public class DesignSpaceExplorationTest {
                                 .symbols(classModel, classElement, classes)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(createClassPrecondition))
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule)
-                                                .strategy(new DepthFirstStrategy(4)
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(0)
                                                 ))
                                 .build();
 
@@ -205,10 +204,9 @@ public class DesignSpaceExplorationTest {
                                 .symbols(classModel, classElement, classes)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(createClassPrecondition))
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule)
-                                                .strategy(new DepthFirstStrategy(4).continueIfHardObjectivesFulfilled()
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
                                                 ))
                                 .build();
 
@@ -274,10 +272,9 @@ public class DesignSpaceExplorationTest {
                                 .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(createClassPrecondition, createFeaturePrecondition))
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule, createFeatureRule)
-                                                .strategy(new DepthFirstStrategy(10).continueIfHardObjectivesFulfilled()
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
                                                 ))
                                 .build();
 
@@ -294,13 +291,81 @@ public class DesignSpaceExplorationTest {
         }
 
         @Test
-        void BFSTrivialTest() {
+        void DFSSolutionLimitTest() {
+                var createClassPrecondition = Query.of("CreateClassPrecondition",
+                                (builder, model) -> builder.clause(
+                                                classModelView.call(model)
+                                ));
+
+                var createClassRule = new TransformationRule("CreateClass",
+                                createClassPrecondition,
+                                (model) -> {
+                                        var classesInterpretation = model.getInterpretation(classes);
+                                        var classElementInterpretation = model.getInterpretation(classElement);
+                                        return ((Tuple activation) -> {
+                                                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                                                var modelElement = activation.get(0);
+
+                                                var newClassElement = dseAdapter.createObject();
+                                                var newClassElementId = newClassElement.get(0);
+
+                                                classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+                                                classElementInterpretation.put(Tuple.of(newClassElementId), true);
+                                        });
+                                });
+
+                var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
+                                (builder, model) -> builder.clause(
+                                                classModelView.call(model)
+                                ));
+
+                var createFeatureRule = new TransformationRule("CreateFeature",
+                                createFeaturePrecondition,
+                                (model) -> {
+                                        var featuresInterpretation = model.getInterpretation(features);
+                                        var featureInterpretation = model.getInterpretation(feature);
+                                        return ((Tuple activation) -> {
+                                                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                                                var modelElement = activation.get(0);
+
+                                                var newClassElement = dseAdapter.createObject();
+                                                var newClassElementId = newClassElement.get(0);
+
+                                                featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+                                                featureInterpretation.put(Tuple.of(newClassElementId), true);
+                                        });
+                                });
+
+                var store = ModelStore.builder()
+                                .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(createClassPrecondition, createFeaturePrecondition))
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .transformations(createClassRule, createFeatureRule)
+                                                .strategy(new DepthFirstStrategy().withSolutionLimit(222)
+                                                                .continueIfHardObjectivesFulfilled()
+                                                ))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+
+                var modelElementInterpretation = model.getInterpretation(classModel);
+                modelElementInterpretation.put(dseAdapter.createObject(), true);
+                queryEngine.flushChanges();
+
+                var states = dseAdapter.explore();
+                assertEquals(222, states.size());
+        }
+
+        @Test
+        void BeFSTrivialTest() {
                 var store = ModelStore.builder()
                                 .symbols(classModel)
                                 .with(ViatraModelQueryAdapter.builder())
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
-                                                .strategy(new BestFirstStrategy(0)))
+                                                .strategy(new BestFirstStrategy().withDepthLimit(0)))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -311,7 +376,7 @@ public class DesignSpaceExplorationTest {
         }
 
         @Test
-        void BFSOneRuleTest() {
+        void BeFSOneRuleTest() {
                 var createClassPrecondition = Query.of("CreateClassPrecondition",
                                 (builder, model) -> builder.clause(
                                                 classModelView.call(model)
@@ -338,10 +403,9 @@ public class DesignSpaceExplorationTest {
                                 .symbols(classModel, classElement, classes)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(createClassPrecondition))
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule)
-                                                .strategy(new BestFirstStrategy(4)
+                                                .strategy(new BestFirstStrategy().withDepthLimit(4)
                                                 ))
                                 .build();
 
@@ -358,7 +422,7 @@ public class DesignSpaceExplorationTest {
         }
 
         @Test
-        void BFSContinueTest() {
+        void BeFSContinueTest() {
                 var createClassPrecondition = Query.of("CreateClassPrecondition",
                                 (builder, model) -> builder.clause(
                                                 classModelView.call(model)
@@ -385,10 +449,9 @@ public class DesignSpaceExplorationTest {
                                 .symbols(classModel, classElement, classes)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(createClassPrecondition))
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule)
-                                                .strategy(new BestFirstStrategy(4).continueIfHardObjectivesFulfilled()
+                                                .strategy(new BestFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
                                                 ))
                                 .build();
 
@@ -405,7 +468,7 @@ public class DesignSpaceExplorationTest {
         }
 
         @Test
-        void BFSCompletenessTest() {
+        void BeFSCompletenessTest() {
                 var createClassPrecondition = Query.of("CreateClassPrecondition",
                                 (builder, model) -> builder.clause(
                                                 classModelView.call(model)
@@ -454,10 +517,9 @@ public class DesignSpaceExplorationTest {
                                 .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(createClassPrecondition, createFeaturePrecondition))
-                                .with(ModelVisualizerAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule, createFeatureRule)
-                                                .strategy(new BestFirstStrategy(10).continueIfHardObjectivesFulfilled()
+                                                .strategy(new BestFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
                                                 ))
                                 .build();
 
@@ -473,4 +535,73 @@ public class DesignSpaceExplorationTest {
                 assertEquals(2047, states.size());
         }
 
+        @Test
+        void BeFSSolutionLimitTest() {
+                var createClassPrecondition = Query.of("CreateClassPrecondition",
+                                (builder, model) -> builder.clause(
+                                                classModelView.call(model)
+                                ));
+
+                var createClassRule = new TransformationRule("CreateClass",
+                                createClassPrecondition,
+                                (model) -> {
+                                        var classesInterpretation = model.getInterpretation(classes);
+                                        var classElementInterpretation = model.getInterpretation(classElement);
+                                        return ((Tuple activation) -> {
+                                                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                                                var modelElement = activation.get(0);
+
+                                                var newClassElement = dseAdapter.createObject();
+                                                var newClassElementId = newClassElement.get(0);
+
+                                                classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+                                                classElementInterpretation.put(Tuple.of(newClassElementId), true);
+                                        });
+                                });
+
+                var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
+                                (builder, model) -> builder.clause(
+                                                classModelView.call(model)
+                                ));
+
+                var createFeatureRule = new TransformationRule("CreateFeature",
+                                createFeaturePrecondition,
+                                (model) -> {
+                                        var featuresInterpretation = model.getInterpretation(features);
+                                        var featureInterpretation = model.getInterpretation(feature);
+                                        return ((Tuple activation) -> {
+                                                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                                                var modelElement = activation.get(0);
+
+                                                var newClassElement = dseAdapter.createObject();
+                                                var newClassElementId = newClassElement.get(0);
+
+                                                featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+                                                featureInterpretation.put(Tuple.of(newClassElementId), true);
+                                        });
+                                });
+
+                var store = ModelStore.builder()
+                                .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(createClassPrecondition, createFeaturePrecondition))
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .transformations(createClassRule, createFeatureRule)
+                                                .strategy(new BestFirstStrategy().withSolutionLimit(222)
+                                                                .continueIfHardObjectivesFulfilled()
+                                                ))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+
+                var modelElementInterpretation = model.getInterpretation(classModel);
+                modelElementInterpretation.put(dseAdapter.createObject(), true);
+                queryEngine.flushChanges();
+
+                var states = dseAdapter.explore();
+                assertEquals(222, states.size());
+        }
+
 }
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..5d24d712 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
@@ -6,6 +6,7 @@
 package tools.refinery.store.dse;
 
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.dse.strategy.DepthFirstStrategy;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.query.dnf.Query;
@@ -23,7 +24,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static tools.refinery.store.query.literal.Literals.not;
 import static tools.refinery.store.dse.tests.QueryAssertions.assertResults;
 
-public class TransformationRuleTest {
+class TransformationRuleTest {
 
         private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
         private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
@@ -103,7 +104,8 @@ public class TransformationRuleTest {
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(assignFeaturePrecondition, assignFeaturePreconditionHelper,
                                                                 deleteEmptyClassPrecondition))
-                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(0)))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -137,8 +139,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,
@@ -195,7 +197,8 @@ public class TransformationRuleTest {
                                 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(deleteEmptyClassPrecondition))
-                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(0)))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -236,12 +239,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);
@@ -276,7 +279,8 @@ public class TransformationRuleTest {
                                 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(deleteEmptyClassPrecondition))
-                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(0)))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -312,7 +316,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 +324,7 @@ public class TransformationRuleTest {
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), false,
                                 Tuple.of(newModelId, newClass2Id), true
-                ), deleteEmptyClassRule.getAllActivationsAsSets());
+                ), deleteEmptyClassRule.getAllActivationsAsResultSet());
         }
 
         @Test
@@ -352,7 +356,8 @@ public class TransformationRuleTest {
                                 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .queries(deleteEmptyClassPrecondition))
-                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy().withDepthLimit(0)))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -388,21 +393,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());
 
         }
 }