1 files changed, 155 insertions, 24 deletions

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());
+        }
+
 }