aboutsummaryrefslogtreecommitdiffstats
path: root/subprojects/store-dse/src/test/java
diff options
context:
space:
mode:
authorLibravatar Kristóf Marussy <kristof@marussy.com>2023-09-07 20:44:48 +0200
committerLibravatar Kristóf Marussy <kristof@marussy.com>2023-09-07 20:44:48 +0200
commitdf8ebe6dae2203513240a3b001fabc2b8b34d505 (patch)
tree5f642cda936c190f2f5525992f17a05be2491920 /subprojects/store-dse/src/test/java
parentfeat: declarative DSE rules and model refinement (diff)
parentAdd missing copyright headers (diff)
downloadrefinery-df8ebe6dae2203513240a3b001fabc2b8b34d505.tar.gz
refinery-df8ebe6dae2203513240a3b001fabc2b8b34d505.tar.zst
refinery-df8ebe6dae2203513240a3b001fabc2b8b34d505.zip
Merge remote-tracking branch 'nagilooh/datastructure' into partial-interpretation
Diffstat (limited to 'subprojects/store-dse/src/test/java')
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java371
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java171
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java596
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java414
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyCriterion.java22
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyObjective.java18
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomCriterion.java25
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomObjective.java23
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java149
9 files changed, 462 insertions, 1327 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 0c50718e..685b88bd 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,271 +5,196 @@
5 */ 5 */
6package tools.refinery.store.dse; 6package tools.refinery.store.dse;
7 7
8import org.junit.jupiter.api.Disabled;
9import org.junit.jupiter.api.Test;
10import tools.refinery.store.dse.modification.DanglingEdges;
11import tools.refinery.store.dse.modification.ModificationAdapter;
12import tools.refinery.store.dse.strategy.BestFirstStoreManager;
13import tools.refinery.store.dse.tests.DummyCriterion;
14import tools.refinery.store.dse.tests.DummyRandomCriterion;
15import tools.refinery.store.dse.tests.DummyRandomObjective;
16import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
17import tools.refinery.store.dse.transition.Rule;
18import tools.refinery.store.model.ModelStore;
19import tools.refinery.store.query.ModelQueryAdapter;
8import tools.refinery.store.query.dnf.Query; 20import tools.refinery.store.query.dnf.Query;
9import tools.refinery.store.query.dnf.RelationalQuery; 21import tools.refinery.store.query.dnf.RelationalQuery;
22import tools.refinery.store.query.term.Variable;
23import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
10import tools.refinery.store.query.view.AnySymbolView; 24import tools.refinery.store.query.view.AnySymbolView;
11import tools.refinery.store.query.view.KeyOnlyView; 25import tools.refinery.store.query.view.KeyOnlyView;
12import tools.refinery.store.representation.Symbol; 26import tools.refinery.store.representation.Symbol;
27import tools.refinery.store.statecoding.StateCoderAdapter;
28import tools.refinery.store.tuple.Tuple;
29import tools.refinery.visualization.ModelVisualizerAdapter;
30import tools.refinery.visualization.internal.FileFormat;
13 31
14import java.util.List; 32import java.util.List;
15 33
34import static tools.refinery.store.dse.modification.actions.ModificationActionLiterals.create;
35import static tools.refinery.store.dse.modification.actions.ModificationActionLiterals.delete;
36import static tools.refinery.store.dse.transition.actions.ActionLiterals.add;
37import static tools.refinery.store.dse.transition.actions.ActionLiterals.remove;
16import static tools.refinery.store.query.literal.Literals.not; 38import static tools.refinery.store.query.literal.Literals.not;
17 39
18class CRAExamplesTest { 40class CRAExamplesTest {
19
20 private static final Symbol<String> name = Symbol.of("Name", 1, String.class); 41 private static final Symbol<String> name = Symbol.of("Name", 1, String.class);
21
22// private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
23 private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1); 42 private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
24// private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
25 private static final Symbol<Boolean> attribute = Symbol.of("Attribute", 1); 43 private static final Symbol<Boolean> attribute = Symbol.of("Attribute", 1);
26 private static final Symbol<Boolean> method = Symbol.of("Method", 1); 44 private static final Symbol<Boolean> method = Symbol.of("Method", 1);
27
28// private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
29 private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2); 45 private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
30 private static final Symbol<Boolean> dataDependency = Symbol.of("DataDependency", 2); 46 private static final Symbol<Boolean> dataDependency = Symbol.of("DataDependency", 2);
31 private static final Symbol<Boolean> functionalDependency = Symbol.of("FunctionalDependency", 2); 47 private static final Symbol<Boolean> functionalDependency = Symbol.of("FunctionalDependency", 2);
32 48
33 private static final Symbol<Boolean> features = Symbol.of("Features", 2);
34 private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
35
36// private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
37 private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement); 49 private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
38// private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
39 private static final AnySymbolView attributeView = new KeyOnlyView<>(attribute); 50 private static final AnySymbolView attributeView = new KeyOnlyView<>(attribute);
40 private static final AnySymbolView methodView = new KeyOnlyView<>(method); 51 private static final AnySymbolView methodView = new KeyOnlyView<>(method);
41// private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
42 private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates); 52 private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
43 private static final AnySymbolView dataDependencyView = new KeyOnlyView<>(dataDependency);
44 private static final AnySymbolView functionalDependencyView = new KeyOnlyView<>(functionalDependency);
45 private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
46 private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
47 53
48 /*Example Transformation rules*/ 54 private static final RelationalQuery feature = Query.of("Feature", (builder, f) -> builder
49 private static final RelationalQuery feature = Query.of("Feature",
50 (builder, f) -> builder.clause(
51 attributeView.call(f))
52 .clause( 55 .clause(
53 methodView.call(f)) 56 attributeView.call(f)
54 ); 57 )
55 58 .clause(
56 private static final RelationalQuery assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper", 59 methodView.call(f)
57 (builder, c, f) -> builder.clause(
58 classElementView.call(c),
59// classesView.call(model, c),
60 encapsulatesView.call(c, f)
61 )); 60 ));
62 61
63 private static final RelationalQuery assignFeaturePrecondition = Query.of("AssignFeaturePrecondition", 62 private static final Rule assignFeatureRule = Rule.of("AssignFeature", (builder, f, c1) -> builder
64 (builder, f, c1) -> builder.clause((c2) -> List.of( 63 .clause(
65// classModelView.call(model),
66 feature.call(f), 64 feature.call(f),
67 classElementView.call(c1), 65 classElementView.call(c1),
68// featuresView.call(model, f), 66 not(encapsulatesView.call(Variable.of(), f))
69 not(assignFeaturePreconditionHelper.call(c2, f)), 67 )
70 not(encapsulatesView.call(c1, f)) 68 .action(
71 ))); 69 add(encapsulates, f, c1)
70 ));
72 71
73 private static final RelationalQuery deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition", 72 private static final Rule deleteEmptyClassRule = Rule.of("DeleteEmptyClass", (builder, c) -> builder
74 (builder, c) -> builder.clause((f) -> List.of( 73 .clause((f) -> List.of(
75// classModelView.call(model),
76 classElementView.call(c), 74 classElementView.call(c),
77// featuresView.call(model, f),
78 not(encapsulatesView.call(c, f)) 75 not(encapsulatesView.call(c, f))
79 ))); 76 ))
80 77 .action(
81 private static final RelationalQuery createClassPreconditionHelper = Query.of("CreateClassPreconditionHelper", 78 remove(classElement, c),
82 (builder, f, c) -> builder.clause( 79 delete(c, DanglingEdges.IGNORE)
83 classElementView.call(c),
84// classesView.call(model, c),
85 encapsulatesView.call(c, f)
86 )); 80 ));
87 81
88 private static final RelationalQuery createClassPrecondition = Query.of("CreateClassPrecondition", 82 private static final Rule createClassRule = Rule.of("CreateClass", (builder, f) -> builder
89 (builder, f) -> builder.clause((c) -> List.of( 83 .clause((c) -> List.of(
90// classModelView.call(model),
91 feature.call(f), 84 feature.call(f),
92 not(createClassPreconditionHelper.call(f, c)) 85 not(encapsulatesView.call(f, c))
86 ))
87 .action((newClass) -> List.of(
88 create(newClass),
89 add(classElement, newClass),
90 add(encapsulates, newClass, f)
93 ))); 91 )));
94 92
95 private static final RelationalQuery moveFeaturePrecondition = Query.of("MoveFeature", 93 private static final Rule moveFeatureRule = Rule.of("MoveFeature", (builder, c1, c2, f) -> builder
96 (builder, c1, c2, f) -> builder.clause( 94 .clause(
97// classModelView.call(model),
98 classElementView.call(c1), 95 classElementView.call(c1),
99 classElementView.call(c2), 96 classElementView.call(c2),
100 c1.notEquivalent(c2), 97 c1.notEquivalent(c2),
101 feature.call(f), 98 feature.call(f),
102// classesView.call(model, c1),
103// classesView.call(model, c2),
104// featuresView.call(model, f),
105 encapsulatesView.call(c1, f) 99 encapsulatesView.call(c1, f)
100 )
101 .action(
102 remove(encapsulates, c1, f),
103 add(encapsulates, c2, f)
106 )); 104 ));
107 105
108// private static final Rule assignFeatureRule = new Rule("AssignFeature", 106 @Test
109// assignFeaturePrecondition, 107 @Disabled("This test is only for debugging purposes")
110// (model) -> { 108 void craTest() {
111//// var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy); 109 var store = ModelStore.builder()
112// var encapsulatesInterpretation = model.getInterpretation(encapsulates); 110 .symbols(classElement, encapsulates, attribute, method, dataDependency, functionalDependency, name)
113// return ((Tuple activation) -> { 111 .with(ViatraModelQueryAdapter.builder())
114// var feature = activation.get(0); 112 .with(ModelVisualizerAdapter.builder()
115// var classElement = activation.get(1); 113 .withOutputpath("test_output")
116// 114 .withFormat(FileFormat.DOT)
117//// isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true); 115 .withFormat(FileFormat.SVG)
118// encapsulatesInterpretation.put(Tuple.of(classElement, feature), true); 116 .saveStates()
119// }); 117 .saveDesignSpace())
120// }); 118 .with(StateCoderAdapter.builder())
121 119 .with(ModificationAdapter.builder())
122// private static final TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass", 120 .with(DesignSpaceExplorationAdapter.builder()
123// deleteEmptyClassPrecondition, 121 .transformations(assignFeatureRule, deleteEmptyClassRule, createClassRule, moveFeatureRule)
124// (model) -> { 122 .objectives(new DummyRandomObjective())
125//// var classesInterpretation = model.getInterpretation(classes); 123 .accept(new DummyRandomCriterion())
126// var classElementInterpretation = model.getInterpretation(classElement); 124 .exclude(new DummyCriterion(false)))
127// return ((Tuple activation) -> { 125 .build();
128// // TODO: can we move dseAdapter outside? 126
129// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class); 127 var model = store.createEmptyModel();
130//// var modelElement = activation.get(0); 128 var queryEngine = model.getAdapter(ModelQueryAdapter.class);
131// var classElement = activation.get(0); 129
132// 130 var nameInterpretation = model.getInterpretation(name);
133//// classesInterpretation.put(Tuple.of(modelElement, classElement), false); 131 var methodInterpretation = model.getInterpretation(method);
134// classElementInterpretation.put(Tuple.of(classElement), false); 132 var attributeInterpretation = model.getInterpretation(attribute);
135// dseAdapter.deleteObject(Tuple.of(classElement)); 133 var dataDependencyInterpretation = model.getInterpretation(dataDependency);
136// }); 134 var functionalDependencyInterpretation = model.getInterpretation(functionalDependency);
137// }); 135
138 136 var modificationAdapter = model.getAdapter(ModificationAdapter.class);
139// private static final TransformationRule createClassRule = new TransformationRule("CreateClass", 137
140// createClassPrecondition, 138 var method1 = modificationAdapter.createObject();
141// (model) -> { 139 var method1Id = method1.get(0);
142// var classElementInterpretation = model.getInterpretation(classElement); 140 var method2 = modificationAdapter.createObject();
143//// var classesInterpretation = model.getInterpretation(classes); 141 var method2Id = method2.get(0);
144// var encapsulatesInterpretation = model.getInterpretation(encapsulates); 142 var method3 = modificationAdapter.createObject();
145// return ((Tuple activation) -> { 143 var method3Id = method3.get(0);
146// // TODO: can we move dseAdapter outside? 144 var method4 = modificationAdapter.createObject();
147// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class); 145 var method4Id = method4.get(0);
148//// var modelElement = activation.get(0); 146 var attribute1 = modificationAdapter.createObject();
149// var feature = activation.get(0); 147 var attribute1Id = attribute1.get(0);
150// 148 var attribute2 = modificationAdapter.createObject();
151// var newClassElement = dseAdapter.createObject(); 149 var attribute2Id = attribute2.get(0);
152// var newClassElementId = newClassElement.get(0); 150 var attribute3 = modificationAdapter.createObject();
153// classElementInterpretation.put(newClassElement, true); 151 var attribute3Id = attribute3.get(0);
154//// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true); 152 var attribute4 = modificationAdapter.createObject();
155// encapsulatesInterpretation.put(Tuple.of(newClassElementId, feature), true); 153 var attribute4Id = attribute4.get(0);
156// }); 154 var attribute5 = modificationAdapter.createObject();
157// }); 155 var attribute5Id = attribute5.get(0);
158 156
159// private static final Rule moveFeatureRule = new Rule("MoveFeature", 157 nameInterpretation.put(method1, "M1");
160// moveFeaturePrecondition, 158 nameInterpretation.put(method2, "M2");
161// (model) -> { 159 nameInterpretation.put(method3, "M3");
162// var encapsulatesInterpretation = model.getInterpretation(encapsulates); 160 nameInterpretation.put(method4, "M4");
163// return ((Tuple activation) -> { 161 nameInterpretation.put(attribute1, "A1");
164// var classElement1 = activation.get(0); 162 nameInterpretation.put(attribute2, "A2");
165// var classElement2 = activation.get(1); 163 nameInterpretation.put(attribute3, "A3");
166// var feature = activation.get(2); 164 nameInterpretation.put(attribute4, "A4");
167// 165 nameInterpretation.put(attribute5, "A5");
168// encapsulatesInterpretation.put(Tuple.of(classElement1, feature), false); 166
169// encapsulatesInterpretation.put(Tuple.of(classElement2, feature), true); 167 methodInterpretation.put(method1, true);
170// }); 168 methodInterpretation.put(method2, true);
171// }); 169 methodInterpretation.put(method3, true);
172 170 methodInterpretation.put(method4, true);
173// @Test 171 attributeInterpretation.put(attribute1, true);
174// @Disabled("This test is only for debugging purposes") 172 attributeInterpretation.put(attribute2, true);
175// void craTest() { 173 attributeInterpretation.put(attribute3, true);
176// var store = ModelStore.builder() 174 attributeInterpretation.put(attribute4, true);
177// .symbols(classElement, encapsulates, classes, features, attribute, method, dataDependency, 175 attributeInterpretation.put(attribute5, true);
178// functionalDependency, name) 176
179// .with(ViatraModelQueryAdapter.builder() 177 dataDependencyInterpretation.put(Tuple.of(method1Id, attribute1Id), true);
180// .queries(feature, assignFeaturePreconditionHelper, assignFeaturePrecondition, 178 dataDependencyInterpretation.put(Tuple.of(method1Id, attribute3Id), true);
181// deleteEmptyClassPrecondition, createClassPreconditionHelper, createClassPrecondition, 179 dataDependencyInterpretation.put(Tuple.of(method2Id, attribute2Id), true);
182// moveFeaturePrecondition)) 180 dataDependencyInterpretation.put(Tuple.of(method3Id, attribute3Id), true);
183// .with(ModelVisualizerAdapter.builder() 181 dataDependencyInterpretation.put(Tuple.of(method3Id, attribute4Id), true);
184// .withOutputpath("test_output") 182 dataDependencyInterpretation.put(Tuple.of(method4Id, attribute3Id), true);
185// .withFormat(FileFormat.DOT) 183 dataDependencyInterpretation.put(Tuple.of(method4Id, attribute5Id), true);
186// .withFormat(FileFormat.SVG) 184
187// .saveStates() 185 functionalDependencyInterpretation.put(Tuple.of(method1Id, attribute3Id), true);
188// .saveDesignSpace() 186 functionalDependencyInterpretation.put(Tuple.of(method1Id, attribute4Id), true);
189// ) 187 functionalDependencyInterpretation.put(Tuple.of(method2Id, attribute1Id), true);
190// .with(DesignSpaceExplorationAdapter.builder() 188 functionalDependencyInterpretation.put(Tuple.of(method3Id, attribute1Id), true);
191// .transformations(assignFeatureRule, deleteEmptyClassRule, createClassRule, moveFeatureRule) 189 functionalDependencyInterpretation.put(Tuple.of(method3Id, attribute4Id), true);
192// .objectives(new AlwaysSatisfiedRandomHardObjective()) 190 functionalDependencyInterpretation.put(Tuple.of(method4Id, attribute2Id), true);
193//// .strategy(new DepthFirstStrategy().withDepthLimit(3).continueIfHardObjectivesFulfilled() 191
194// .strategy(new BestFirstStrategy().withDepthLimit(6).continueIfHardObjectivesFulfilled() 192 var initialVersion = model.commit();
195//// .goOnOnlyIfFitnessIsBetter() 193 queryEngine.flushChanges();
196// )) 194
197// .build(); 195 var bestFirst = new BestFirstStoreManager(store);
198// 196 bestFirst.startExploration(initialVersion);
199// var model = store.createEmptyModel(); 197 var resultStore = bestFirst.getSolutionStore();
200// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class); 198 System.out.println("states size: " + resultStore.getSolutions().size());
201//// dseAdapter.setRandom(1); 199 }
202// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
203//
204//// var modelInterpretation = model.getInterpretation(classModel);
205// var nameInterpretation = model.getInterpretation(name);
206// var methodInterpretation = model.getInterpretation(method);
207// var attributeInterpretation = model.getInterpretation(attribute);
208// var dataDependencyInterpretation = model.getInterpretation(dataDependency);
209// var functionalDependencyInterpretation = model.getInterpretation(functionalDependency);
210//
211//// var modelElement = dseAdapter.createObject();
212// var method1 = dseAdapter.createObject();
213// var method1Id = method1.get(0);
214// var method2 = dseAdapter.createObject();
215// var method2Id = method2.get(0);
216// var method3 = dseAdapter.createObject();
217// var method3Id = method3.get(0);
218// var method4 = dseAdapter.createObject();
219// var method4Id = method4.get(0);
220// var attribute1 = dseAdapter.createObject();
221// var attribute1Id = attribute1.get(0);
222// var attribute2 = dseAdapter.createObject();
223// var attribute2Id = attribute2.get(0);
224// var attribute3 = dseAdapter.createObject();
225// var attribute3Id = attribute3.get(0);
226// var attribute4 = dseAdapter.createObject();
227// var attribute4Id = attribute4.get(0);
228// var attribute5 = dseAdapter.createObject();
229// var attribute5Id = attribute5.get(0);
230//
231// nameInterpretation.put(method1, "M1");
232// nameInterpretation.put(method2, "M2");
233// nameInterpretation.put(method3, "M3");
234// nameInterpretation.put(method4, "M4");
235// nameInterpretation.put(attribute1, "A1");
236// nameInterpretation.put(attribute2, "A2");
237// nameInterpretation.put(attribute3, "A3");
238// nameInterpretation.put(attribute4, "A4");
239// nameInterpretation.put(attribute5, "A5");
240//
241//
242//
243//// modelInterpretation.put(modelElement, true);
244// methodInterpretation.put(method1, true);
245// methodInterpretation.put(method2, true);
246// methodInterpretation.put(method3, true);
247// methodInterpretation.put(method4, true);
248// attributeInterpretation.put(attribute1, true);
249// attributeInterpretation.put(attribute2, true);
250// attributeInterpretation.put(attribute3, true);
251// attributeInterpretation.put(attribute4, true);
252// attributeInterpretation.put(attribute5, true);
253//
254// dataDependencyInterpretation.put(Tuple.of(method1Id, attribute1Id), true);
255// dataDependencyInterpretation.put(Tuple.of(method1Id, attribute3Id), true);
256// dataDependencyInterpretation.put(Tuple.of(method2Id, attribute2Id), true);
257// dataDependencyInterpretation.put(Tuple.of(method3Id, attribute3Id), true);
258// dataDependencyInterpretation.put(Tuple.of(method3Id, attribute4Id), true);
259// dataDependencyInterpretation.put(Tuple.of(method4Id, attribute3Id), true);
260// dataDependencyInterpretation.put(Tuple.of(method4Id, attribute5Id), true);
261//
262// functionalDependencyInterpretation.put(Tuple.of(method1Id, attribute3Id), true);
263// functionalDependencyInterpretation.put(Tuple.of(method1Id, attribute4Id), true);
264// functionalDependencyInterpretation.put(Tuple.of(method2Id, attribute1Id), true);
265// functionalDependencyInterpretation.put(Tuple.of(method3Id, attribute1Id), true);
266// functionalDependencyInterpretation.put(Tuple.of(method3Id, attribute4Id), true);
267// functionalDependencyInterpretation.put(Tuple.of(method4Id, attribute2Id), true);
268//
269// queryEngine.flushChanges();
270//
271// var states = dseAdapter.explore();
272// System.out.println("states size: " + states.size());
273// }
274//*/
275} 200}
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 1d757a5f..baa7c8a4 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,112 +5,95 @@
5 */ 5 */
6package tools.refinery.store.dse; 6package tools.refinery.store.dse;
7 7
8import org.junit.jupiter.api.Disabled;
9import org.junit.jupiter.api.Test;
10import tools.refinery.store.dse.modification.ModificationAdapter;
11import tools.refinery.store.dse.strategy.BestFirstStoreManager;
12import tools.refinery.store.dse.tests.DummyRandomCriterion;
13import tools.refinery.store.dse.tests.DummyRandomObjective;
14import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
15import tools.refinery.store.dse.transition.Rule;
16import tools.refinery.store.model.ModelStore;
17import tools.refinery.store.query.ModelQueryAdapter;
18import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
8import tools.refinery.store.query.view.AnySymbolView; 19import tools.refinery.store.query.view.AnySymbolView;
9import tools.refinery.store.query.view.KeyOnlyView; 20import tools.refinery.store.query.view.KeyOnlyView;
10import tools.refinery.store.representation.Symbol; 21import tools.refinery.store.representation.Symbol;
22import tools.refinery.store.statecoding.StateCoderAdapter;
23import tools.refinery.visualization.ModelVisualizerAdapter;
24import tools.refinery.visualization.internal.FileFormat;
25
26import java.util.List;
27
28import static tools.refinery.store.dse.modification.actions.ModificationActionLiterals.create;
29import static tools.refinery.store.dse.transition.actions.ActionLiterals.add;
11 30
12class DebugTest { 31class DebugTest {
13 private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1); 32 private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
14 private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1); 33 private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
15 private static final Symbol<Boolean> feature = Symbol.of("Feature", 1); 34 private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
16
17 private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
18 private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
19
20 private static final Symbol<Boolean> features = Symbol.of("Features", 2); 35 private static final Symbol<Boolean> features = Symbol.of("Features", 2);
21 private static final Symbol<Boolean> classes = Symbol.of("Classes", 2); 36 private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
22 37
23 private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel); 38 private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
24 private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
25 private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
26 private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
27 private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
28 private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
29 private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
30 39
40 @Test
41 @Disabled("This test is only for debugging purposes")
42 void BFSTest() {
43 var createClassRule = Rule.of("CreateClass", (builder, model) -> builder
44 .clause(
45 classModelView.call(model)
46 )
47 .action((newClassElement) -> List.of(
48 create(newClassElement),
49 add(classElement, newClassElement),
50 add(classes, model, newClassElement)
51 )));
52
53 var createFeatureRule = Rule.of("CreateFeature", (builder, model) -> builder
54 .clause(
55 classModelView.call(model)
56 )
57 .action((newFeature) -> List.of(
58 create(newFeature),
59 add(feature, newFeature),
60 add(features, model, newFeature)
61 )));
62
63 var store = ModelStore.builder()
64 .symbols(classModel, classElement, feature, classes, features)
65 .with(ViatraModelQueryAdapter.builder())
66 .with(ModelVisualizerAdapter.builder()
67 .withOutputpath("test_output")
68 .withFormat(FileFormat.DOT)
69 .withFormat(FileFormat.SVG)
70 .saveStates()
71 .saveDesignSpace())
72 .with(StateCoderAdapter.builder())
73 .with(ModificationAdapter.builder())
74 .with(DesignSpaceExplorationAdapter.builder()
75 .transformations(createClassRule, createFeatureRule)
76 .objectives(new DummyRandomObjective())
77 .accept(new DummyRandomCriterion())
78 .exclude(new DummyRandomCriterion()))
79 .build();
80
81 var model = store.createEmptyModel();
82 var dseAdapter = model.getAdapter(ModificationAdapter.class);
83// dseAdapter.setRandom(1);
84 var queryEngine = model.getAdapter(ModelQueryAdapter.class);
85
86 var modelElementInterpretation = model.getInterpretation(classModel);
87 var classElementInterpretation = model.getInterpretation(classElement);
88 var modelElement = dseAdapter.createObject();
89 modelElementInterpretation.put(modelElement, true);
90 classElementInterpretation.put(modelElement, true);
91 var initialVersion = model.commit();
92 queryEngine.flushChanges();
31 93
32// @Test 94 var bestFirst = new BestFirstStoreManager(store);
33// @Disabled("This test is only for debugging purposes") 95 bestFirst.startExploration(initialVersion);
34// void BFSTest() { 96 var resultStore = bestFirst.getSolutionStore();
35// var createClassPrecondition = Query.of("CreateClassPrecondition", 97 System.out.println("states size: " + resultStore.getSolutions().size());
36// (builder, model) -> builder.clause( 98 }
37// classModelView.call(model)
38// ));
39//
40// var createClassRule = new TransformationRule("CreateClass",
41// createClassPrecondition,
42// (model) -> {
43// var classesInterpretation = model.getInterpretation(classes);
44// var classElementInterpretation = model.getInterpretation(classElement);
45// return ((Tuple activation) -> {
46// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
47// var modelElement = activation.get(0);
48//
49// var newClassElement = dseAdapter.createObject();
50// var newClassElementId = newClassElement.get(0);
51//
52// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
53// classElementInterpretation.put(Tuple.of(newClassElementId), true);
54// });
55// });
56//
57// var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
58// (builder, model) -> builder.clause(
59// classModelView.call(model)
60// ));
61//
62// var createFeatureRule = new TransformationRule("CreateFeature",
63// createFeaturePrecondition,
64// (model) -> {
65// var featuresInterpretation = model.getInterpretation(features);
66// var featureInterpretation = model.getInterpretation(feature);
67// return ((Tuple activation) -> {
68// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
69// var modelElement = activation.get(0);
70//
71// var newClassElement = dseAdapter.createObject();
72// var newClassElementId = newClassElement.get(0);
73//
74// featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
75// featureInterpretation.put(Tuple.of(newClassElementId), true);
76// });
77// });
78//
79// var store = ModelStore.builder()
80// .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
81// .with(ViatraModelQueryAdapter.builder()
82// .queries(createClassPrecondition, createFeaturePrecondition))
83// .with(ModelVisualizerAdapter.builder()
84// .withOutputpath("test_output")
85// .withFormat(FileFormat.DOT)
86// .withFormat(FileFormat.SVG)
87// .saveStates()
88// .saveDesignSpace()
89// )
90// .with(DesignSpaceExplorationAdapter.builder()
91// .transformations(createClassRule, createFeatureRule)
92// .objectives(new AlwaysSatisfiedRandomHardObjective())
93// .strategy(new DepthFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
94//// .strategy(new BestFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
95//// .goOnOnlyIfFitnessIsBetter()
96// ))
97// .build();
98//
99// var model = store.createEmptyModel();
100// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
101//// dseAdapter.setRandom(1);
102// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
103//
104// var modelElementInterpretation = model.getInterpretation(classModel);
105// var classElementInterpretation = model.getInterpretation(classElement);
106// var modelElement = dseAdapter.createObject();
107// modelElementInterpretation.put(modelElement, true);
108// classElementInterpretation.put(modelElement, true);
109// queryEngine.flushChanges();
110//
111//
112// var states = dseAdapter.explore();
113// System.out.println("states size: " + states.size());
114//
115// }
116} 99}
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
deleted file mode 100644
index f5f13433..00000000
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
+++ /dev/null
@@ -1,596 +0,0 @@
1/*
2 * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
3 *
4 * SPDX-License-Identifier: EPL-2.0
5 */
6package tools.refinery.store.dse;
7
8import tools.refinery.store.query.view.AnySymbolView;
9import tools.refinery.store.query.view.KeyOnlyView;
10import tools.refinery.store.representation.Symbol;
11
12class DesignSpaceExplorationTest {
13// private static final Symbol<Boolean> namedElement = Symbol.of("NamedElement", 1);
14// private static final Symbol<Boolean> attribute = Symbol.of("Attribute", 1);
15// private static final Symbol<Boolean> method = Symbol.of("Method", 1);
16// private static final Symbol<Boolean> dataDependency = Symbol.of("DataDependency", 2);
17// private static final Symbol<Boolean> functionalDependency = Symbol.of("FunctionalDependency", 2);
18
19 private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
20 private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
21 private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
22
23 private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
24 private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
25
26 private static final Symbol<Boolean> features = Symbol.of("Features", 2);
27 private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
28
29 private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
30 private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
31 private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
32 private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
33 private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
34 private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
35 private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
36
37// @Test
38// void createObjectTest() {
39// var store = ModelStore.builder()
40// .with(ViatraModelQueryAdapter.builder())
41// .with(DesignSpaceExplorationAdapter.builder()
42// .strategy(new DepthFirstStrategy().withDepthLimit(0)))
43// .build();
44//
45// var model = store.createEmptyModel();
46// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
47//
48// assertEquals(0, dseAdapter.getModelSize());
49//
50// var newModel = dseAdapter.createObject();
51// var newModelId = newModel.get(0);
52// var newClass1 = dseAdapter.createObject();
53// var newClass1Id = newClass1.get(0);
54// var newClass2 = dseAdapter.createObject();
55// var newClass2Id = newClass2.get(0);
56// var newField = dseAdapter.createObject();
57// var newFieldId = newField.get(0);
58//
59// assertEquals(0, newModelId);
60// assertEquals(1, newClass1Id);
61// assertEquals(2, newClass2Id);
62// assertEquals(3, newFieldId);
63// assertEquals(4, dseAdapter.getModelSize());
64// }
65
66// @Test
67// void deleteMiddleObjectTest() {
68// var store = ModelStore.builder()
69// .with(ViatraModelQueryAdapter.builder())
70// .with(DesignSpaceExplorationAdapter.builder()
71// .strategy(new DepthFirstStrategy()))
72// .build();
73//
74// var model = store.createEmptyModel();
75// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
76//
77// assertEquals(0, dseAdapter.getModelSize());
78//
79// var newObject0 = dseAdapter.createObject();
80// var newObject0Id = newObject0.get(0);
81// var newObject1 = dseAdapter.createObject();
82// var newObject1Id = newObject1.get(0);
83// var newObject2 = dseAdapter.createObject();
84// var newObject2Id = newObject2.get(0);
85// var newObject3 = dseAdapter.createObject();
86// var newObject3Id = newObject3.get(0);
87//
88// assertEquals(0, newObject0Id);
89// assertEquals(1, newObject1Id);
90// assertEquals(2, newObject2Id);
91// assertEquals(3, newObject3Id);
92// assertEquals(4, dseAdapter.getModelSize());
93//
94// dseAdapter.deleteObject(newObject1);
95// assertEquals(4, dseAdapter.getModelSize());
96//
97// var newObject4 = dseAdapter.createObject();
98// var newObject4Id = newObject4.get(0);
99// assertEquals(4, newObject4Id);
100// assertEquals(5, dseAdapter.getModelSize());
101//
102// dseAdapter.deleteObject(newObject4);
103// assertEquals(5, dseAdapter.getModelSize());
104// }
105//
106// @Test
107// void DFSTrivialTest() {
108// var store = ModelStore.builder()
109// .symbols(classModel)
110// .with(ViatraModelQueryAdapter.builder())
111// .with(DesignSpaceExplorationAdapter.builder()
112// .strategy(new DepthFirstStrategy().withDepthLimit(0)))
113// .build();
114//
115// var model = store.createEmptyModel();
116// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
117//
118// var states = dseAdapter.explore();
119// assertEquals(1, states.size());
120// }
121//
122// @Test
123// void DFSOneRuleTest() {
124// var createClassPrecondition = Query.of("CreateClassPrecondition",
125// (builder, model) -> builder.clause(
126// classModelView.call(model)
127// ));
128//
129// var createClassRule = new TransformationRule("CreateClass",
130// createClassPrecondition,
131// (model) -> {
132// var classesInterpretation = model.getInterpretation(classes);
133// var classElementInterpretation = model.getInterpretation(classElement);
134// return ((Tuple activation) -> {
135// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
136// var modelElement = activation.get(0);
137//
138// var newClassElement = dseAdapter.createObject();
139// var newClassElementId = newClassElement.get(0);
140//
141// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
142// classElementInterpretation.put(Tuple.of(newClassElementId), true);
143// });
144// });
145//
146// var store = ModelStore.builder()
147// .symbols(classModel, classElement, classes)
148// .with(ViatraModelQueryAdapter.builder()
149// .queries(createClassPrecondition))
150// .with(DesignSpaceExplorationAdapter.builder()
151// .transformations(createClassRule)
152// .strategy(new DepthFirstStrategy().withDepthLimit(0)
153// ))
154// .build();
155//
156// var model = store.createEmptyModel();
157// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
158// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
159//
160// var modelElementInterpretation = model.getInterpretation(classModel);
161// modelElementInterpretation.put(dseAdapter.createObject(), true);
162// queryEngine.flushChanges();
163//
164// var states = dseAdapter.explore();
165// assertEquals(1, states.size());
166// }
167//
168// @Test
169// void DFSContinueTest() {
170// var createClassPrecondition = Query.of("CreateClassPrecondition",
171// (builder, model) -> builder.clause(
172// classModelView.call(model)
173// ));
174//
175// var createClassRule = new TransformationRule("CreateClass",
176// createClassPrecondition,
177// (model) -> {
178// var classesInterpretation = model.getInterpretation(classes);
179// var classElementInterpretation = model.getInterpretation(classElement);
180// return ((Tuple activation) -> {
181// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
182// var modelElement = activation.get(0);
183//
184// var newClassElement = dseAdapter.createObject();
185// var newClassElementId = newClassElement.get(0);
186//
187// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
188// classElementInterpretation.put(Tuple.of(newClassElementId), true);
189// });
190// });
191//
192// var store = ModelStore.builder()
193// .symbols(classModel, classElement, classes)
194// .with(ViatraModelQueryAdapter.builder()
195// .queries(createClassPrecondition))
196// .with(DesignSpaceExplorationAdapter.builder()
197// .transformations(createClassRule)
198// .strategy(new DepthFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
199// ))
200// .build();
201//
202// var model = store.createEmptyModel();
203// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
204// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
205//
206// var modelElementInterpretation = model.getInterpretation(classModel);
207// modelElementInterpretation.put(dseAdapter.createObject(), true);
208// queryEngine.flushChanges();
209//
210// var states = dseAdapter.explore();
211// assertEquals(5, states.size());
212// }
213//
214// @Test
215// void DFSCompletenessTest() {
216// var createClassPrecondition = Query.of("CreateClassPrecondition",
217// (builder, model) -> builder.clause(
218// classModelView.call(model)
219// ));
220//
221// var createClassRule = new TransformationRule("CreateClass",
222// createClassPrecondition,
223// (model) -> {
224// var classesInterpretation = model.getInterpretation(classes);
225// var classElementInterpretation = model.getInterpretation(classElement);
226// return ((Tuple activation) -> {
227// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
228// var modelElement = activation.get(0);
229//
230// var newClassElement = dseAdapter.createObject();
231// var newClassElementId = newClassElement.get(0);
232//
233// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
234// classElementInterpretation.put(Tuple.of(newClassElementId), true);
235// });
236// });
237//
238// var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
239// (builder, model) -> builder.clause(
240// classModelView.call(model)
241// ));
242//
243// var createFeatureRule = new TransformationRule("CreateFeature",
244// createFeaturePrecondition,
245// (model) -> {
246// var featuresInterpretation = model.getInterpretation(features);
247// var featureInterpretation = model.getInterpretation(feature);
248// return ((Tuple activation) -> {
249// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
250// var modelElement = activation.get(0);
251//
252// var newClassElement = dseAdapter.createObject();
253// var newClassElementId = newClassElement.get(0);
254//
255// featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
256// featureInterpretation.put(Tuple.of(newClassElementId), true);
257// });
258// });
259//
260// var store = ModelStore.builder()
261// .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
262// .with(ViatraModelQueryAdapter.builder()
263// .queries(createClassPrecondition, createFeaturePrecondition))
264// .with(DesignSpaceExplorationAdapter.builder()
265// .transformations(createClassRule, createFeatureRule)
266// .strategy(new DepthFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
267// ))
268// .build();
269//
270// var model = store.createEmptyModel();
271// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
272// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
273//
274// var modelElementInterpretation = model.getInterpretation(classModel);
275// modelElementInterpretation.put(dseAdapter.createObject(), true);
276// queryEngine.flushChanges();
277//
278// var states = dseAdapter.explore();
279// assertEquals(2047, states.size());
280// }
281//
282// @Test
283// void DFSSolutionLimitTest() {
284// var createClassPrecondition = Query.of("CreateClassPrecondition",
285// (builder, model) -> builder.clause(
286// classModelView.call(model)
287// ));
288//
289// var createClassRule = new TransformationRule("CreateClass",
290// createClassPrecondition,
291// (model) -> {
292// var classesInterpretation = model.getInterpretation(classes);
293// var classElementInterpretation = model.getInterpretation(classElement);
294// return ((Tuple activation) -> {
295// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
296// var modelElement = activation.get(0);
297//
298// var newClassElement = dseAdapter.createObject();
299// var newClassElementId = newClassElement.get(0);
300//
301// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
302// classElementInterpretation.put(Tuple.of(newClassElementId), true);
303// });
304// });
305//
306// var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
307// (builder, model) -> builder.clause(
308// classModelView.call(model)
309// ));
310//
311// var createFeatureRule = new TransformationRule("CreateFeature",
312// createFeaturePrecondition,
313// (model) -> {
314// var featuresInterpretation = model.getInterpretation(features);
315// var featureInterpretation = model.getInterpretation(feature);
316// return ((Tuple activation) -> {
317// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
318// var modelElement = activation.get(0);
319//
320// var newClassElement = dseAdapter.createObject();
321// var newClassElementId = newClassElement.get(0);
322//
323// featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
324// featureInterpretation.put(Tuple.of(newClassElementId), true);
325// });
326// });
327//
328// var store = ModelStore.builder()
329// .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
330// .with(ViatraModelQueryAdapter.builder()
331// .queries(createClassPrecondition, createFeaturePrecondition))
332// .with(DesignSpaceExplorationAdapter.builder()
333// .transformations(createClassRule, createFeatureRule)
334// .strategy(new DepthFirstStrategy().withSolutionLimit(222)
335// .continueIfHardObjectivesFulfilled()
336// ))
337// .build();
338//
339// var model = store.createEmptyModel();
340// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
341// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
342//
343// var modelElementInterpretation = model.getInterpretation(classModel);
344// modelElementInterpretation.put(dseAdapter.createObject(), true);
345// queryEngine.flushChanges();
346//
347// var states = dseAdapter.explore();
348// assertEquals(222, states.size());
349// }
350//
351// @Test
352// void BeFSTrivialTest() {
353// var store = ModelStore.builder()
354// .symbols(classModel)
355// .with(ViatraModelQueryAdapter.builder())
356// .with(DesignSpaceExplorationAdapter.builder()
357// .strategy(new BestFirstStrategy().withDepthLimit(0)))
358// .build();
359//
360// var model = store.createEmptyModel();
361// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
362//
363// var states = dseAdapter.explore();
364// assertEquals(1, states.size());
365// }
366//
367// @Test
368// void BeFSOneRuleTest() {
369// var createClassPrecondition = Query.of("CreateClassPrecondition",
370// (builder, model) -> builder.clause(
371// classModelView.call(model)
372// ));
373//
374// var createClassRule = new TransformationRule("CreateClass",
375// createClassPrecondition,
376// (model) -> {
377// var classesInterpretation = model.getInterpretation(classes);
378// var classElementInterpretation = model.getInterpretation(classElement);
379// return ((Tuple activation) -> {
380// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
381// var modelElement = activation.get(0);
382//
383// var newClassElement = dseAdapter.createObject();
384// var newClassElementId = newClassElement.get(0);
385//
386// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
387// classElementInterpretation.put(Tuple.of(newClassElementId), true);
388// });
389// });
390//
391// var store = ModelStore.builder()
392// .symbols(classModel, classElement, classes)
393// .with(ViatraModelQueryAdapter.builder()
394// .queries(createClassPrecondition))
395// .with(DesignSpaceExplorationAdapter.builder()
396// .transformations(createClassRule)
397// .strategy(new BestFirstStrategy().withDepthLimit(4)
398// ))
399// .build();
400//
401// var model = store.createEmptyModel();
402// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
403// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
404//
405// var modelElementInterpretation = model.getInterpretation(classModel);
406// modelElementInterpretation.put(dseAdapter.createObject(), true);
407// queryEngine.flushChanges();
408//
409// var states = dseAdapter.explore();
410// assertEquals(1, states.size());
411// }
412//
413// @Test
414// void BeFSContinueTest() {
415// var createClassPrecondition = Query.of("CreateClassPrecondition",
416// (builder, model) -> builder.clause(
417// classModelView.call(model)
418// ));
419//
420// var createClassRule = new TransformationRule("CreateClass",
421// createClassPrecondition,
422// (model) -> {
423// var classesInterpretation = model.getInterpretation(classes);
424// var classElementInterpretation = model.getInterpretation(classElement);
425// return ((Tuple activation) -> {
426// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
427// var modelElement = activation.get(0);
428//
429// var newClassElement = dseAdapter.createObject();
430// var newClassElementId = newClassElement.get(0);
431//
432// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
433// classElementInterpretation.put(Tuple.of(newClassElementId), true);
434// });
435// });
436//
437// var store = ModelStore.builder()
438// .symbols(classModel, classElement, classes)
439// .with(ViatraModelQueryAdapter.builder()
440// .queries(createClassPrecondition))
441// .with(DesignSpaceExplorationAdapter.builder()
442// .transformations(createClassRule)
443// .strategy(new BestFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
444// ))
445// .build();
446//
447// var model = store.createEmptyModel();
448// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
449// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
450//
451// var modelElementInterpretation = model.getInterpretation(classModel);
452// modelElementInterpretation.put(dseAdapter.createObject(), true);
453// queryEngine.flushChanges();
454//
455// var states = dseAdapter.explore();
456// assertEquals(5, states.size());
457// }
458//
459// @Test
460// void BeFSCompletenessTest() {
461// var createClassPrecondition = Query.of("CreateClassPrecondition",
462// (builder, model) -> builder.clause(
463// classModelView.call(model)
464// ));
465//
466// var createClassRule = new TransformationRule("CreateClass",
467// createClassPrecondition,
468// (model) -> {
469// var classesInterpretation = model.getInterpretation(classes);
470// var classElementInterpretation = model.getInterpretation(classElement);
471// return ((Tuple activation) -> {
472// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
473// var modelElement = activation.get(0);
474//
475// var newClassElement = dseAdapter.createObject();
476// var newClassElementId = newClassElement.get(0);
477//
478// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
479// classElementInterpretation.put(Tuple.of(newClassElementId), true);
480// });
481// });
482//
483// var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
484// (builder, model) -> builder.clause(
485// classModelView.call(model)
486// ));
487//
488// var createFeatureRule = new TransformationRule("CreateFeature",
489// createFeaturePrecondition,
490// (model) -> {
491// var featuresInterpretation = model.getInterpretation(features);
492// var featureInterpretation = model.getInterpretation(feature);
493// return ((Tuple activation) -> {
494// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
495// var modelElement = activation.get(0);
496//
497// var newClassElement = dseAdapter.createObject();
498// var newClassElementId = newClassElement.get(0);
499//
500// featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
501// featureInterpretation.put(Tuple.of(newClassElementId), true);
502// });
503// });
504//
505// var store = ModelStore.builder()
506// .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
507// .with(ViatraModelQueryAdapter.builder()
508// .queries(createClassPrecondition, createFeaturePrecondition))
509// .with(DesignSpaceExplorationAdapter.builder()
510// .transformations(createClassRule, createFeatureRule)
511// .strategy(new BestFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
512// ))
513// .build();
514//
515// var model = store.createEmptyModel();
516// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
517// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
518//
519// var modelElementInterpretation = model.getInterpretation(classModel);
520// modelElementInterpretation.put(dseAdapter.createObject(), true);
521// queryEngine.flushChanges();
522//
523// var states = dseAdapter.explore();
524// assertEquals(2047, states.size());
525// }
526//
527// @Test
528// void BeFSSolutionLimitTest() {
529// var createClassPrecondition = Query.of("CreateClassPrecondition",
530// (builder, model) -> builder.clause(
531// classModelView.call(model)
532// ));
533//
534// var createClassRule = new TransformationRule("CreateClass",
535// createClassPrecondition,
536// (model) -> {
537// var classesInterpretation = model.getInterpretation(classes);
538// var classElementInterpretation = model.getInterpretation(classElement);
539// return ((Tuple activation) -> {
540// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
541// var modelElement = activation.get(0);
542//
543// var newClassElement = dseAdapter.createObject();
544// var newClassElementId = newClassElement.get(0);
545//
546// classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
547// classElementInterpretation.put(Tuple.of(newClassElementId), true);
548// });
549// });
550//
551// var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
552// (builder, model) -> builder.clause(
553// classModelView.call(model)
554// ));
555//
556// var createFeatureRule = new TransformationRule("CreateFeature",
557// createFeaturePrecondition,
558// (model) -> {
559// var featuresInterpretation = model.getInterpretation(features);
560// var featureInterpretation = model.getInterpretation(feature);
561// return ((Tuple activation) -> {
562// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
563// var modelElement = activation.get(0);
564//
565// var newClassElement = dseAdapter.createObject();
566// var newClassElementId = newClassElement.get(0);
567//
568// featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
569// featureInterpretation.put(Tuple.of(newClassElementId), true);
570// });
571// });
572//
573// var store = ModelStore.builder()
574// .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
575// .with(ViatraModelQueryAdapter.builder()
576// .queries(createClassPrecondition, createFeaturePrecondition))
577// .with(DesignSpaceExplorationAdapter.builder()
578// .transformations(createClassRule, createFeatureRule)
579// .strategy(new BestFirstStrategy().withSolutionLimit(222)
580// .continueIfHardObjectivesFulfilled()
581// ))
582// .build();
583//
584// var model = store.createEmptyModel();
585// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
586// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
587//
588// var modelElementInterpretation = model.getInterpretation(classModel);
589// modelElementInterpretation.put(dseAdapter.createObject(), true);
590// queryEngine.flushChanges();
591//
592// var states = dseAdapter.explore();
593// assertEquals(222, states.size());
594// }
595
596}
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
deleted file mode 100644
index 43b04e0d..00000000
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
+++ /dev/null
@@ -1,414 +0,0 @@
1/*
2 * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
3 *
4 * SPDX-License-Identifier: EPL-2.0
5 */
6package tools.refinery.store.dse;
7
8import org.junit.jupiter.api.Test;
9//
10//import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
11//import tools.refinery.store.model.ModelStore;
12//import tools.refinery.store.query.ModelQueryAdapter;
13//import tools.refinery.store.query.dnf.Query;
14//import tools.refinery.store.dse.transition.TransformationRule;
15//import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
16//import tools.refinery.store.query.view.AnySymbolView;
17//import tools.refinery.store.query.view.KeyOnlyView;
18//import tools.refinery.store.representation.Symbol;
19//import tools.refinery.store.tuple.Tuple;
20//
21//import java.util.List;
22//import java.util.Map;
23//
24//import static org.junit.jupiter.api.Assertions.assertEquals;
25//import static tools.refinery.store.query.literal.Literals.not;
26//import static tools.refinery.store.dse.tests.QueryAssertions.assertResults;
27//
28class TransformationRuleTest {
29//
30// private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
31// private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
32// private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
33//
34// private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
35// private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
36//
37// private static final Symbol<Boolean> features = Symbol.of("Features", 2);
38// private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
39//
40// private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
41// private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
42// private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
43// private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
44// private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
45// private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
46// private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
47//
48// @Test
49// void activationsTest() {
50// var assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper",
51// (builder, model, c, f) -> builder.clause(
52// classElementView.call(c),
53// classesView.call(model, c),
54// encapsulatesView.call(c, f)
55// ));
56//
57// var assignFeaturePrecondition = Query.of("AssignFeaturePrecondition", (builder, c2, f)
58// -> builder.clause((model, c1) -> List.of(
59// classModelView.call(model),
60// featureView.call(f),
61// classElementView.call(c2),
62// featuresView.call(model, f),
63// classesView.call(model, c1),
64// not(assignFeaturePreconditionHelper.call(model, c2, f)),
65// not(encapsulatesView.call(c2, f))
66// )));
67//
68// var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
69// (builder, model, c) -> builder.clause((f) -> List.of(
70// classModelView.call(model),
71// classElementView.call(c),
72// featuresView.call(model, f),
73// not(encapsulatesView.call(c, f))
74// )));
75//
76// TransformationRule assignFeatureRule = new TransformationRule("AssignFeature",
77// assignFeaturePrecondition,
78// (model) -> {
79// var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy);
80// return ((Tuple activation) -> {
81// var feature = activation.get(0);
82// var classElement = activation.get(1);
83//
84// isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true);
85// });
86// });
87//
88// TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
89// deleteEmptyClassPrecondition,
90// (model) -> {
91// var classesInterpretation = model.getInterpretation(classes);
92// var classElementInterpretation = model.getInterpretation(classElement);
93// return ((Tuple activation) -> {
94// var modelElement = activation.get(0);
95// var classElement = activation.get(1);
96//
97// classesInterpretation.put(Tuple.of(modelElement, classElement), false);
98// classElementInterpretation.put(Tuple.of(classElement), false);
99// });
100// });
101//
102//
103// var store = ModelStore.builder()
104// .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
105// .with(ViatraModelQueryAdapter.builder()
106// .queries(assignFeaturePrecondition, assignFeaturePreconditionHelper,
107// deleteEmptyClassPrecondition))
108// .with(DesignSpaceExplorationAdapter.builder()
109// .strategy(new DepthFirstStrategy().withDepthLimit(0)))
110// .build();
111//
112// var model = store.createEmptyModel();
113// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
114// assignFeatureRule.prepare(model, queryEngine);
115// deleteEmptyClassRule.prepare(model, queryEngine);
116//
117// var classModelInterpretation = model.getInterpretation(classModel);
118// var classElementInterpretation = model.getInterpretation(classElement);
119// var featureInterpretation = model.getInterpretation(feature);
120// var featuresInterpretation = model.getInterpretation(features);
121// var classesInterpretation = model.getInterpretation(classes);
122//
123// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
124// var newModel = dseAdapter.createObject();
125// var newModelId = newModel.get(0);
126// var newClass1 = dseAdapter.createObject();
127// var newClass1Id = newClass1.get(0);
128// var newClass2 = dseAdapter.createObject();
129// var newClass2Id = newClass2.get(0);
130// var newField = dseAdapter.createObject();
131// var newFieldId = newField.get(0);
132//
133// classModelInterpretation.put(newModel, true);
134// classElementInterpretation.put(newClass1, true);
135// classElementInterpretation.put(newClass2, true);
136// featureInterpretation.put(newField, true);
137// classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
138// classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
139// featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
140//
141// queryEngine.flushChanges();
142//
143// var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsResultSet();
144// var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsResultSet();
145//
146// assertResults(Map.of(
147// Tuple.of(newClass1Id, newFieldId), true,
148// Tuple.of(newClass2Id, newFieldId), true
149// ), assignFeatureRuleActivations);
150//
151// assertResults(Map.of(
152// Tuple.of(newModelId, newClass1Id), true,
153// Tuple.of(newModelId, newClass2Id), true
154// ), deleteEmptyClassRuleActivations);
155// }
156//
157// @Test
158// void randomActivationTest() {
159// var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
160// (builder, model, c) -> builder.clause((f) -> List.of(
161// classModelView.call(model),
162// classElementView.call(c),
163// featuresView.call(model, f),
164// not(encapsulatesView.call(c, f))
165// )));
166//
167// TransformationRule deleteEmptyClassRule0 = new TransformationRule("DeleteEmptyClass0",
168// deleteEmptyClassPrecondition,
169// (model) -> {
170// var classesInterpretation = model.getInterpretation(classes);
171// var classElementInterpretation = model.getInterpretation(classElement);
172// return ((Tuple activation) -> {
173// var modelElement = activation.get(0);
174// var classElement = activation.get(1);
175//
176// classesInterpretation.put(Tuple.of(modelElement, classElement), false);
177// classElementInterpretation.put(Tuple.of(classElement), false);
178// });
179// },
180// 0L);
181//
182// TransformationRule deleteEmptyClassRule1 = new TransformationRule("DeleteEmptyClass1",
183// deleteEmptyClassPrecondition,
184// (model) -> {
185// var classesInterpretation = model.getInterpretation(classes);
186// var classElementInterpretation = model.getInterpretation(classElement);
187// return ((Tuple activation) -> {
188// var modelElement = activation.get(0);
189// var classElement = activation.get(1);
190//
191// classesInterpretation.put(Tuple.of(modelElement, classElement), false);
192// classElementInterpretation.put(Tuple.of(classElement), false);
193// });
194// },
195// 78634L);
196//
197// var store = ModelStore.builder()
198// .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
199// .with(ViatraModelQueryAdapter.builder()
200// .queries(deleteEmptyClassPrecondition))
201// .with(DesignSpaceExplorationAdapter.builder()
202// .strategy(new DepthFirstStrategy().withDepthLimit(0)))
203// .build();
204//
205// var model = store.createEmptyModel();
206// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
207// deleteEmptyClassRule0.prepare(model, queryEngine);
208// deleteEmptyClassRule1.prepare(model, queryEngine);
209//
210// var classModelInterpretation = model.getInterpretation(classModel);
211// var classElementInterpretation = model.getInterpretation(classElement);
212// var featureInterpretation = model.getInterpretation(feature);
213// var featuresInterpretation = model.getInterpretation(features);
214// var classesInterpretation = model.getInterpretation(classes);
215//
216// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
217// var newModel = dseAdapter.createObject();
218// var newModelId = newModel.get(0);
219// var newClass1 = dseAdapter.createObject();
220// var newClass1Id = newClass1.get(0);
221// var newClass2 = dseAdapter.createObject();
222// var newClass2Id = newClass2.get(0);
223// var newField = dseAdapter.createObject();
224// var newFieldId = newField.get(0);
225//
226// classModelInterpretation.put(newModel, true);
227// classElementInterpretation.put(newClass1, true);
228// classElementInterpretation.put(newClass2, true);
229// featureInterpretation.put(newField, true);
230// classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
231// classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
232// featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
233//
234// queryEngine.flushChanges();
235//
236//
237// var activation0 = deleteEmptyClassRule0.getRandomActivation().activation();
238// var activation1 = deleteEmptyClassRule1.getRandomActivation().activation();
239//
240// assertResults(Map.of(
241// Tuple.of(newModelId, newClass1Id), true,
242// Tuple.of(newModelId, newClass2Id), true
243// ), deleteEmptyClassRule0.getAllActivationsAsResultSet());
244//
245// assertResults(Map.of(
246// Tuple.of(newModelId, newClass1Id), true,
247// Tuple.of(newModelId, newClass2Id), true
248// ), deleteEmptyClassRule1.getAllActivationsAsResultSet());
249//
250// assertEquals(Tuple.of(newModelId, newClass2Id), activation0);
251// assertEquals(Tuple.of(newModelId, newClass1Id), activation1);
252//
253// }
254//
255// @Test
256// void fireTest() {
257// var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
258// (builder, model, c) -> builder.clause((f) -> List.of(
259// classModelView.call(model),
260// classElementView.call(c),
261// featuresView.call(model, f),
262// not(encapsulatesView.call(c, f))
263// )));
264//
265// TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
266// deleteEmptyClassPrecondition,
267// (model) -> {
268// var classesInterpretation = model.getInterpretation(classes);
269// var classElementInterpretation = model.getInterpretation(classElement);
270// return ((Tuple activation) -> {
271// var modelElement = activation.get(0);
272// var classElement = activation.get(1);
273//
274// classesInterpretation.put(Tuple.of(modelElement, classElement), false);
275// classElementInterpretation.put(Tuple.of(classElement), false);
276// });
277// });
278//
279// var store = ModelStore.builder()
280// .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
281// .with(ViatraModelQueryAdapter.builder()
282// .queries(deleteEmptyClassPrecondition))
283// .with(DesignSpaceExplorationAdapter.builder()
284// .strategy(new DepthFirstStrategy().withDepthLimit(0)))
285// .build();
286//
287// var model = store.createEmptyModel();
288// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
289// deleteEmptyClassRule.prepare(model, queryEngine);
290//
291// var classModelInterpretation = model.getInterpretation(classModel);
292// var classElementInterpretation = model.getInterpretation(classElement);
293// var featureInterpretation = model.getInterpretation(feature);
294// var featuresInterpretation = model.getInterpretation(features);
295// var classesInterpretation = model.getInterpretation(classes);
296//
297// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
298// var newModel = dseAdapter.createObject();
299// var newModelId = newModel.get(0);
300// var newClass1 = dseAdapter.createObject();
301// var newClass1Id = newClass1.get(0);
302// var newClass2 = dseAdapter.createObject();
303// var newClass2Id = newClass2.get(0);
304// var newField = dseAdapter.createObject();
305// var newFieldId = newField.get(0);
306//
307// classModelInterpretation.put(newModel, true);
308// classElementInterpretation.put(newClass1, true);
309// classElementInterpretation.put(newClass2, true);
310// featureInterpretation.put(newField, true);
311// classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
312// classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
313// featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
314//
315// queryEngine.flushChanges();
316//
317// assertResults(Map.of(
318// Tuple.of(newModelId, newClass1Id), true,
319// Tuple.of(newModelId, newClass2Id), true
320// ), deleteEmptyClassRule.getAllActivationsAsResultSet());
321//
322//
323// deleteEmptyClassRule.fireActivation(Tuple.of(0, 1));
324//
325// assertResults(Map.of(
326// Tuple.of(newModelId, newClass1Id), false,
327// Tuple.of(newModelId, newClass2Id), true
328// ), deleteEmptyClassRule.getAllActivationsAsResultSet());
329// }
330//
331// @Test
332// void randomFireTest() {
333// var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
334// (builder, model, c) -> builder.clause((f) -> List.of(
335// classModelView.call(model),
336// classElementView.call(c),
337// featuresView.call(model, f),
338// not(encapsulatesView.call(c, f))
339// )));
340//
341// TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass0",
342// deleteEmptyClassPrecondition,
343// (model) -> {
344// var classesInterpretation = model.getInterpretation(classes);
345// var classElementInterpretation = model.getInterpretation(classElement);
346// return ((Tuple activation) -> {
347// var modelElement = activation.get(0);
348// var classElement = activation.get(1);
349//
350// classesInterpretation.put(Tuple.of(modelElement, classElement), false);
351// classElementInterpretation.put(Tuple.of(classElement), false);
352// });
353// },
354// 0L);
355//
356// var store = ModelStore.builder()
357// .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
358// .with(ViatraModelQueryAdapter.builder()
359// .queries(deleteEmptyClassPrecondition))
360// .with(DesignSpaceExplorationAdapter.builder()
361// .strategy(new DepthFirstStrategy().withDepthLimit(0)))
362// .build();
363//
364// var model = store.createEmptyModel();
365// var queryEngine = model.getAdapter(ModelQueryAdapter.class);
366// deleteEmptyClassRule.prepare(model, queryEngine);
367//
368// var classModelInterpretation = model.getInterpretation(classModel);
369// var classElementInterpretation = model.getInterpretation(classElement);
370// var featureInterpretation = model.getInterpretation(feature);
371// var featuresInterpretation = model.getInterpretation(features);
372// var classesInterpretation = model.getInterpretation(classes);
373//
374// var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
375// var newModel = dseAdapter.createObject();
376// var newModelId = newModel.get(0);
377// var newClass1 = dseAdapter.createObject();
378// var newClass1Id = newClass1.get(0);
379// var newClass2 = dseAdapter.createObject();
380// var newClass2Id = newClass2.get(0);
381// var newField = dseAdapter.createObject();
382// var newFieldId = newField.get(0);
383//
384// classModelInterpretation.put(newModel, true);
385// classElementInterpretation.put(newClass1, true);
386// classElementInterpretation.put(newClass2, true);
387// featureInterpretation.put(newField, true);
388// classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
389// classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
390// featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
391//
392// queryEngine.flushChanges();
393//
394// assertResults(Map.of(
395// Tuple.of(newModelId, newClass1Id), true,
396// Tuple.of(newModelId, newClass2Id), true
397// ), deleteEmptyClassRule.getAllActivationsAsResultSet());
398//
399// deleteEmptyClassRule.fireRandomActivation();
400//
401// assertResults(Map.of(
402// Tuple.of(newModelId, newClass1Id), true,
403// Tuple.of(newModelId, newClass2Id), false
404// ), deleteEmptyClassRule.getAllActivationsAsResultSet());
405//
406// deleteEmptyClassRule.fireRandomActivation();
407//
408// assertResults(Map.of(
409// Tuple.of(newModelId, newClass1Id), false,
410// Tuple.of(newModelId, newClass2Id), false
411// ), deleteEmptyClassRule.getAllActivationsAsResultSet());
412//
413// }
414}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyCriterion.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyCriterion.java
new file mode 100644
index 00000000..2d5a0f36
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyCriterion.java
@@ -0,0 +1,22 @@
1/*
2 * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
3 *
4 * SPDX-License-Identifier: EPL-2.0
5 */
6package tools.refinery.store.dse.tests;
7
8import tools.refinery.store.dse.transition.objectives.Criterion;
9import tools.refinery.store.dse.transition.objectives.CriterionCalculator;
10import tools.refinery.store.model.Model;
11
12public class DummyCriterion implements Criterion {
13 protected final boolean returnValue;
14 public DummyCriterion(boolean returnValue) {
15 this.returnValue = returnValue;
16 }
17
18 @Override
19 public CriterionCalculator createCalculator(Model model) {
20 return () -> returnValue;
21 }
22}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyObjective.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyObjective.java
new file mode 100644
index 00000000..f5d281aa
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyObjective.java
@@ -0,0 +1,18 @@
1/*
2 * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
3 *
4 * SPDX-License-Identifier: EPL-2.0
5 */
6package tools.refinery.store.dse.tests;
7
8import tools.refinery.store.dse.transition.objectives.Objective;
9import tools.refinery.store.dse.transition.objectives.ObjectiveCalculator;
10import tools.refinery.store.model.Model;
11
12public class DummyObjective implements Objective {
13
14 @Override
15 public ObjectiveCalculator createCalculator(Model model) {
16 return () -> {return 0d;};
17 }
18}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomCriterion.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomCriterion.java
new file mode 100644
index 00000000..71fd4403
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomCriterion.java
@@ -0,0 +1,25 @@
1/*
2 * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
3 *
4 * SPDX-License-Identifier: EPL-2.0
5 */
6package tools.refinery.store.dse.tests;
7
8import tools.refinery.store.dse.transition.objectives.Criterion;
9import tools.refinery.store.dse.transition.objectives.CriterionCalculator;
10import tools.refinery.store.model.Model;
11
12import java.util.Random;
13
14public class DummyRandomCriterion implements Criterion {
15
16 @SuppressWarnings("squid:S2245")
17 private static final Random random = new Random(9856654);
18 public DummyRandomCriterion() {
19 }
20
21 @Override
22 public CriterionCalculator createCalculator(Model model) {
23 return random::nextBoolean;
24 }
25}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomObjective.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomObjective.java
new file mode 100644
index 00000000..219e74c6
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/DummyRandomObjective.java
@@ -0,0 +1,23 @@
1/*
2 * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
3 *
4 * SPDX-License-Identifier: EPL-2.0
5 */
6package tools.refinery.store.dse.tests;
7
8import tools.refinery.store.dse.transition.objectives.Objective;
9import tools.refinery.store.dse.transition.objectives.ObjectiveCalculator;
10import tools.refinery.store.model.Model;
11
12import java.util.Random;
13
14public class DummyRandomObjective implements Objective {
15
16 @SuppressWarnings("squid:S2245")
17 private static final Random random = new Random(9856654);
18
19 @Override
20 public ObjectiveCalculator createCalculator(Model model) {
21 return random::nextDouble;
22 }
23}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java
new file mode 100644
index 00000000..42a0f89b
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java
@@ -0,0 +1,149 @@
1/*
2 * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
3 *
4 * SPDX-License-Identifier: EPL-2.0
5 */
6package tools.refinery.store.dse.transition;
7
8import org.junit.jupiter.api.Test;
9import tools.refinery.store.dse.modification.ModificationAdapter;
10import tools.refinery.store.dse.transition.objectives.Criteria;
11import tools.refinery.store.dse.transition.objectives.Objectives;
12import tools.refinery.store.model.Model;
13import tools.refinery.store.model.ModelStore;
14import tools.refinery.store.query.ModelQueryAdapter;
15import tools.refinery.store.query.dnf.FunctionalQuery;
16import tools.refinery.store.query.dnf.Query;
17import tools.refinery.store.query.dnf.RelationalQuery;
18import tools.refinery.store.query.term.Variable;
19import tools.refinery.store.query.term.int_.IntTerms;
20import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
21import tools.refinery.store.query.view.AnySymbolView;
22import tools.refinery.store.query.view.KeyOnlyView;
23import tools.refinery.store.representation.Symbol;
24import tools.refinery.store.statecoding.StateCoderAdapter;
25import tools.refinery.store.tuple.Tuple;
26
27import java.util.List;
28
29import static org.junit.jupiter.api.Assertions.*;
30import static tools.refinery.store.query.literal.Literals.check;
31import static tools.refinery.store.query.literal.Literals.not;
32
33class TransitionBuildTests {
34 Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
35 Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
36
37 AnySymbolView personView = new KeyOnlyView<>(person);
38 AnySymbolView friendView = new KeyOnlyView<>(friend);
39
40 RelationalQuery moreThan3Friends = Query.of("moreThan3Friends", (builder, tooMuchFriends) -> builder
41 .clause(Integer.class, (numberOfFriends) -> List.of(
42 numberOfFriends.assign(friendView.count(tooMuchFriends, Variable.of())),
43 check(IntTerms.less(IntTerms.constant(3), numberOfFriends)),
44 personView.call(tooMuchFriends)
45 )));
46
47 RelationalQuery somebodyHasNoFriend = Query.of("somebodyHasNoFriend", (builder, lonely) -> builder
48 .clause(
49 personView.call(lonely),
50 not(friendView.call(lonely, Variable.of()))
51 ));
52
53 FunctionalQuery<Integer> numberOfFriends = Query.of(Integer.class, (builder, output) -> builder
54 .clause(
55 output.assign(friendView.count(Variable.of(), Variable.of()))
56 ));
57
58 @Test
59 void acceptTest() {
60 Model model = getModel();
61
62 var dse = model.getAdapter(DesignSpaceExplorationAdapter.class);
63 var query = model.getAdapter(ModelQueryAdapter.class);
64 var personI = model.getInterpretation(person);
65 var friendI = model.getInterpretation(friend);
66
67 assertTrue(dse.checkAccept());
68 personI.put(Tuple.of(1), true);
69 personI.put(Tuple.of(2), true);
70
71 query.flushChanges();
72
73 assertFalse(dse.checkAccept());
74 friendI.put(Tuple.of(1, 2), true);
75 friendI.put(Tuple.of(2, 1), true);
76
77 query.flushChanges();
78
79 assertTrue(dse.checkAccept());
80 }
81
82 @Test
83 void includeTest() {
84 Model model = getModel();
85
86 var dse = model.getAdapter(DesignSpaceExplorationAdapter.class);
87 var query = model.getAdapter(ModelQueryAdapter.class);
88 var personI = model.getInterpretation(person);
89 var friendI = model.getInterpretation(friend);
90
91 assertFalse(dse.checkExclude());
92
93 personI.put(Tuple.of(1), true);
94 friendI.put(Tuple.of(1, 2), true);
95 friendI.put(Tuple.of(1, 3), true);
96 friendI.put(Tuple.of(1, 4), true);
97
98 query.flushChanges();
99 assertFalse(dse.checkExclude());
100
101 personI.put(Tuple.of(5), true);
102 friendI.put(Tuple.of(1, 5), true);
103
104 query.flushChanges();
105 assertTrue(dse.checkExclude());
106
107 friendI.put(Tuple.of(1, 2), false);
108
109 query.flushChanges();
110 assertFalse(dse.checkExclude());
111 }
112
113 @Test
114 void objectiveTest() {
115 Model model = getModel();
116
117 var dse = model.getAdapter(DesignSpaceExplorationAdapter.class);
118 var query = model.getAdapter(ModelQueryAdapter.class);
119 var friendI = model.getInterpretation(friend);
120
121 assertEquals(0.0, dse.getObjectiveValue().get(0), 0.01);
122
123 friendI.put(Tuple.of(1, 2), true);
124
125 query.flushChanges();
126 assertEquals(1.0, dse.getObjectiveValue().get(0), 0.01);
127
128 friendI.put(Tuple.of(1, 3), true);
129 friendI.put(Tuple.of(1, 4), true);
130
131 query.flushChanges();
132 assertEquals(3.0, dse.getObjectiveValue().get(0), 0.01);
133 }
134
135 private Model getModel() {
136 var store = ModelStore.builder()
137 .symbols(person, friend)
138 .with(ViatraModelQueryAdapter.builder())
139 .with(StateCoderAdapter.builder())
140 .with(ModificationAdapter.builder())
141 .with(DesignSpaceExplorationAdapter.builder()
142 .objective(Objectives.value(numberOfFriends))
143 .exclude(Criteria.whenHasMatch(moreThan3Friends))
144 .accept(Criteria.whenNoMatch(somebodyHasNoFriend)))
145 .build();
146
147 return store.createEmptyModel();
148 }
149}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-21 04:34:01 +0000