Add new test files

3 files changed, 251 insertions, 0 deletions

diff --git a/subprojects/store-query-viatra/build.gradle.kts b/subprojects/store-query-viatra/build.gradle.kts
index 85ea7e2e..1f804247 100644
--- a/subprojects/store-query-viatra/build.gradle.kts
+++ b/subprojects/store-query-viatra/build.gradle.kts
@@ -10,7 +10,9 @@ plugins {
 
 dependencies {
         implementation(libs.ecore)
+        implementation ("guru.nidi:graphviz-java:0.18.1")
         api(libs.viatra)
         api(project(":refinery-store-query"))
         api(project(":refinery-store-reasoning"))
+        api(project(":refinery-visualization"))
 }
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/CRAExamplesTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/CRAExamplesTest.java
new file mode 100644
index 00000000..8fe50a42
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/CRAExamplesTest.java
@@ -0,0 +1,135 @@
+package tools.refinery.store.query.dse;
+
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.dse.internal.TransformationRule;
+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 java.util.List;
+
+import static tools.refinery.store.query.literal.Literals.not;
+
+public class CRAExamplesTest {
+        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);
+
+        private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+        private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+
+        private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+        private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+
+        private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+        private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+        private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+        private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+        private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+
+        /*Example Transformation rules*/
+        private static final RelationalQuery assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper",
+                        (builder, model, c, f) -> builder.clause(
+                                        classElementView.call(c),
+                                        classesView.call(model, c),
+                                        encapsulatesView.call(c, f)
+                        ));
+
+        private static final RelationalQuery assignFeaturePrecondition = Query.of("AssignFeaturePrecondition", (builder, c2, f)
+                        -> builder.clause((model, c1) -> List.of(
+                                        classModelView.call(model),
+                                        featureView.call(f),
+                                        classElementView.call(c2),
+                                        featuresView.call(model, f),
+                                        classesView.call(model, c1),
+                                        not(assignFeaturePreconditionHelper.call(model, c2, f)),
+                                        not(encapsulatesView.call(c2, f))
+                        )));
+
+        private static final RelationalQuery deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+                        (builder, model, c) -> builder.clause((f) -> List.of(
+                                        classModelView.call(model),
+                                        classElementView.call(c),
+                                        featuresView.call(model, f),
+                                        not(encapsulatesView.call(c, f))
+                        )));
+
+        private static final RelationalQuery createClassPreconditionHelper = Query.of("CreateClassPreconditionHelper",
+                        (builder, model, f, c) -> builder.clause(
+                                        classElementView.call(c),
+                                        classesView.call(model, c),
+                                        encapsulatesView.call(c, f)
+                        ));
+
+        private static final RelationalQuery createClassPrecondition = Query.of("CreateClassPrecondition",
+                        (builder, model, f) -> builder.clause((c) -> List.of(
+                                        classModelView.call(model),
+                                        featureView.call(f),
+                                        not(createClassPreconditionHelper.call(model, f, c))
+                        )));
+
+        private static final RelationalQuery moveFeature = Query.of("MoveFeature",
+                        (builder, c1, c2, f) -> builder.clause((model) -> List.of(
+                                        classModelView.call(model),
+                                        classElementView.call(c1),
+                                        classElementView.call(c2),
+                                        featureView.call(f),
+                                        classesView.call(model, c1),
+                                        classesView.call(model, c2),
+                                        featuresView.call(model, f),
+                                        encapsulatesView.call(c1, f)
+                        )));
+
+        private static final TransformationRule assignFeatureRule = new TransformationRule("AssignFeature",
+                        assignFeaturePrecondition,
+                        (model) -> {
+                                var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy);
+                                return ((Tuple activation) -> {
+                                        var feature = activation.get(0);
+                                        var classElement = activation.get(1);
+
+                                        isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true);
+                                });
+                        });
+
+        private static final TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
+                        deleteEmptyClassPrecondition,
+                        (model) -> {
+                                var classesInterpretation = model.getInterpretation(classes);
+                                var classElementInterpretation = model.getInterpretation(classElement);
+                                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                                return ((Tuple activation) -> {
+                                        var modelElement = activation.get(0);
+                                        var classElement = activation.get(1);
+
+                                        classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+                                        classElementInterpretation.put(Tuple.of(classElement), false);
+                                        dseAdapter.deleteObject(Tuple.of(classElement));
+                                });
+                        });
+
+        private static final TransformationRule createClassRule = new TransformationRule("CreateClass",
+                        createClassPrecondition,
+                        (model) -> {
+                                var adapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                                var classElementInterpretation = model.getInterpretation(classElement);
+                                var classesInterpretation = model.getInterpretation(classes);
+                                var encapsulatesInterpretation = model.getInterpretation(encapsulates);
+                                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                                return ((Tuple activation) -> {
+                                        var modelElement = activation.get(0);
+                                        var feature = activation.get(1);
+
+                                        var newClassElement = dseAdapter.createObject();
+                                        var newClassElementId = newClassElement.get(0);
+                                        classElementInterpretation.put(newClassElement, true);
+                                        classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+                                        encapsulatesInterpretation.put(Tuple.of(newClassElementId, feature), true);
+                                });
+                        });
+
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/DebugTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/DebugTest.java
new file mode 100644
index 00000000..969afbcb
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/DebugTest.java
@@ -0,0 +1,114 @@
+package tools.refinery.store.query.dse;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dse.internal.TransformationRule;
+import tools.refinery.store.query.dse.strategy.DepthFirstStrategy;
+import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+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;
+
+public 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);
+
+        private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+        private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+
+        private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+        private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+
+        private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+        private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+        private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+        private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+        private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+
+
+        @Test
+        void BFSTest() {
+                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, feature, isEncapsulatedBy, encapsulates, classes, features)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(createClassPrecondition, createFeaturePrecondition))
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .transformations(createClassRule, createFeatureRule)
+                                                .strategy(new DepthFirstStrategy(4).continueIfHardObjectivesFulfilled()
+//                                              .strategy(new BestFirstStrategy(4).continueIfHardObjectivesFulfilled()
+//                                                              .goOnOnlyIfFitnessIsBetter()
+                                                ))
+                                .with(ModelVisualizerAdapter.builder())
+                                .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();
+                var visualizer = model.getAdapter(ModelVisualizerAdapter.class);
+                for (var state : states) {
+                        var visualization = visualizer.createVisualizationForModelState(state);
+                        visualizer.saveVisualization(visualization, "test_output" + state.hashCode() + ".png");
+                }
+                System.out.println("states size: " + states.size());
+                System.out.println("states: " + states);
+
+        }
+}