aboutsummaryrefslogtreecommitdiffstats
path: root/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
diff options
context:
space:
mode:
Diffstat (limited to 'subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java')
-rw-r--r--subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java413
1 files changed, 0 insertions, 413 deletions
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 5d24d712..00000000
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
+++ /dev/null
@@ -1,413 +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;
9import tools.refinery.store.dse.strategy.DepthFirstStrategy;
10import tools.refinery.store.model.ModelStore;
11import tools.refinery.store.query.ModelQueryAdapter;
12import tools.refinery.store.query.dnf.Query;
13import tools.refinery.store.dse.internal.TransformationRule;
14import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
15import tools.refinery.store.query.view.AnySymbolView;
16import tools.refinery.store.query.view.KeyOnlyView;
17import tools.refinery.store.representation.Symbol;
18import tools.refinery.store.tuple.Tuple;
19
20import java.util.List;
21import java.util.Map;
22
23import static org.junit.jupiter.api.Assertions.assertEquals;
24import static tools.refinery.store.query.literal.Literals.not;
25import static tools.refinery.store.dse.tests.QueryAssertions.assertResults;
26
27class TransformationRuleTest {
28
29 private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
30 private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
31 private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
32
33 private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
34 private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
35
36 private static final Symbol<Boolean> features = Symbol.of("Features", 2);
37 private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
38
39 private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
40 private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
41 private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
42 private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
43 private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
44 private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
45 private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
46
47 @Test
48 void activationsTest() {
49 var assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper",
50 (builder, model, c, f) -> builder.clause(
51 classElementView.call(c),
52 classesView.call(model, c),
53 encapsulatesView.call(c, f)
54 ));
55
56 var assignFeaturePrecondition = Query.of("AssignFeaturePrecondition", (builder, c2, f)
57 -> builder.clause((model, c1) -> List.of(
58 classModelView.call(model),
59 featureView.call(f),
60 classElementView.call(c2),
61 featuresView.call(model, f),
62 classesView.call(model, c1),
63 not(assignFeaturePreconditionHelper.call(model, c2, f)),
64 not(encapsulatesView.call(c2, f))
65 )));
66
67 var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
68 (builder, model, c) -> builder.clause((f) -> List.of(
69 classModelView.call(model),
70 classElementView.call(c),
71 featuresView.call(model, f),
72 not(encapsulatesView.call(c, f))
73 )));
74
75 TransformationRule assignFeatureRule = new TransformationRule("AssignFeature",
76 assignFeaturePrecondition,
77 (model) -> {
78 var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy);
79 return ((Tuple activation) -> {
80 var feature = activation.get(0);
81 var classElement = activation.get(1);
82
83 isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true);
84 });
85 });
86
87 TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
88 deleteEmptyClassPrecondition,
89 (model) -> {
90 var classesInterpretation = model.getInterpretation(classes);
91 var classElementInterpretation = model.getInterpretation(classElement);
92 return ((Tuple activation) -> {
93 var modelElement = activation.get(0);
94 var classElement = activation.get(1);
95
96 classesInterpretation.put(Tuple.of(modelElement, classElement), false);
97 classElementInterpretation.put(Tuple.of(classElement), false);
98 });
99 });
100
101
102 var store = ModelStore.builder()
103 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
104 .with(ViatraModelQueryAdapter.builder()
105 .queries(assignFeaturePrecondition, assignFeaturePreconditionHelper,
106 deleteEmptyClassPrecondition))
107 .with(DesignSpaceExplorationAdapter.builder()
108 .strategy(new DepthFirstStrategy().withDepthLimit(0)))
109 .build();
110
111 var model = store.createEmptyModel();
112 var queryEngine = model.getAdapter(ModelQueryAdapter.class);
113 assignFeatureRule.prepare(model, queryEngine);
114 deleteEmptyClassRule.prepare(model, queryEngine);
115
116 var classModelInterpretation = model.getInterpretation(classModel);
117 var classElementInterpretation = model.getInterpretation(classElement);
118 var featureInterpretation = model.getInterpretation(feature);
119 var featuresInterpretation = model.getInterpretation(features);
120 var classesInterpretation = model.getInterpretation(classes);
121
122 var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
123 var newModel = dseAdapter.createObject();
124 var newModelId = newModel.get(0);
125 var newClass1 = dseAdapter.createObject();
126 var newClass1Id = newClass1.get(0);
127 var newClass2 = dseAdapter.createObject();
128 var newClass2Id = newClass2.get(0);
129 var newField = dseAdapter.createObject();
130 var newFieldId = newField.get(0);
131
132 classModelInterpretation.put(newModel, true);
133 classElementInterpretation.put(newClass1, true);
134 classElementInterpretation.put(newClass2, true);
135 featureInterpretation.put(newField, true);
136 classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
137 classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
138 featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
139
140 queryEngine.flushChanges();
141
142 var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsResultSet();
143 var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsResultSet();
144
145 assertResults(Map.of(
146 Tuple.of(newClass1Id, newFieldId), true,
147 Tuple.of(newClass2Id, newFieldId), true
148 ), assignFeatureRuleActivations);
149
150 assertResults(Map.of(
151 Tuple.of(newModelId, newClass1Id), true,
152 Tuple.of(newModelId, newClass2Id), true
153 ), deleteEmptyClassRuleActivations);
154 }
155
156 @Test
157 void randomActivationTest() {
158 var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
159 (builder, model, c) -> builder.clause((f) -> List.of(
160 classModelView.call(model),
161 classElementView.call(c),
162 featuresView.call(model, f),
163 not(encapsulatesView.call(c, f))
164 )));
165
166 TransformationRule deleteEmptyClassRule0 = new TransformationRule("DeleteEmptyClass0",
167 deleteEmptyClassPrecondition,
168 (model) -> {
169 var classesInterpretation = model.getInterpretation(classes);
170 var classElementInterpretation = model.getInterpretation(classElement);
171 return ((Tuple activation) -> {
172 var modelElement = activation.get(0);
173 var classElement = activation.get(1);
174
175 classesInterpretation.put(Tuple.of(modelElement, classElement), false);
176 classElementInterpretation.put(Tuple.of(classElement), false);
177 });
178 },
179 0L);
180
181 TransformationRule deleteEmptyClassRule1 = new TransformationRule("DeleteEmptyClass1",
182 deleteEmptyClassPrecondition,
183 (model) -> {
184 var classesInterpretation = model.getInterpretation(classes);
185 var classElementInterpretation = model.getInterpretation(classElement);
186 return ((Tuple activation) -> {
187 var modelElement = activation.get(0);
188 var classElement = activation.get(1);
189
190 classesInterpretation.put(Tuple.of(modelElement, classElement), false);
191 classElementInterpretation.put(Tuple.of(classElement), false);
192 });
193 },
194 78634L);
195
196 var store = ModelStore.builder()
197 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
198 .with(ViatraModelQueryAdapter.builder()
199 .queries(deleteEmptyClassPrecondition))
200 .with(DesignSpaceExplorationAdapter.builder()
201 .strategy(new DepthFirstStrategy().withDepthLimit(0)))
202 .build();
203
204 var model = store.createEmptyModel();
205 var queryEngine = model.getAdapter(ModelQueryAdapter.class);
206 deleteEmptyClassRule0.prepare(model, queryEngine);
207 deleteEmptyClassRule1.prepare(model, queryEngine);
208
209 var classModelInterpretation = model.getInterpretation(classModel);
210 var classElementInterpretation = model.getInterpretation(classElement);
211 var featureInterpretation = model.getInterpretation(feature);
212 var featuresInterpretation = model.getInterpretation(features);
213 var classesInterpretation = model.getInterpretation(classes);
214
215 var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
216 var newModel = dseAdapter.createObject();
217 var newModelId = newModel.get(0);
218 var newClass1 = dseAdapter.createObject();
219 var newClass1Id = newClass1.get(0);
220 var newClass2 = dseAdapter.createObject();
221 var newClass2Id = newClass2.get(0);
222 var newField = dseAdapter.createObject();
223 var newFieldId = newField.get(0);
224
225 classModelInterpretation.put(newModel, true);
226 classElementInterpretation.put(newClass1, true);
227 classElementInterpretation.put(newClass2, true);
228 featureInterpretation.put(newField, true);
229 classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
230 classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
231 featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
232
233 queryEngine.flushChanges();
234
235
236 var activation0 = deleteEmptyClassRule0.getRandomActivation().activation();
237 var activation1 = deleteEmptyClassRule1.getRandomActivation().activation();
238
239 assertResults(Map.of(
240 Tuple.of(newModelId, newClass1Id), true,
241 Tuple.of(newModelId, newClass2Id), true
242 ), deleteEmptyClassRule0.getAllActivationsAsResultSet());
243
244 assertResults(Map.of(
245 Tuple.of(newModelId, newClass1Id), true,
246 Tuple.of(newModelId, newClass2Id), true
247 ), deleteEmptyClassRule1.getAllActivationsAsResultSet());
248
249 assertEquals(Tuple.of(newModelId, newClass2Id), activation0);
250 assertEquals(Tuple.of(newModelId, newClass1Id), activation1);
251
252 }
253
254 @Test
255 void fireTest() {
256 var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
257 (builder, model, c) -> builder.clause((f) -> List.of(
258 classModelView.call(model),
259 classElementView.call(c),
260 featuresView.call(model, f),
261 not(encapsulatesView.call(c, f))
262 )));
263
264 TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
265 deleteEmptyClassPrecondition,
266 (model) -> {
267 var classesInterpretation = model.getInterpretation(classes);
268 var classElementInterpretation = model.getInterpretation(classElement);
269 return ((Tuple activation) -> {
270 var modelElement = activation.get(0);
271 var classElement = activation.get(1);
272
273 classesInterpretation.put(Tuple.of(modelElement, classElement), false);
274 classElementInterpretation.put(Tuple.of(classElement), false);
275 });
276 });
277
278 var store = ModelStore.builder()
279 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
280 .with(ViatraModelQueryAdapter.builder()
281 .queries(deleteEmptyClassPrecondition))
282 .with(DesignSpaceExplorationAdapter.builder()
283 .strategy(new DepthFirstStrategy().withDepthLimit(0)))
284 .build();
285
286 var model = store.createEmptyModel();
287 var queryEngine = model.getAdapter(ModelQueryAdapter.class);
288 deleteEmptyClassRule.prepare(model, queryEngine);
289
290 var classModelInterpretation = model.getInterpretation(classModel);
291 var classElementInterpretation = model.getInterpretation(classElement);
292 var featureInterpretation = model.getInterpretation(feature);
293 var featuresInterpretation = model.getInterpretation(features);
294 var classesInterpretation = model.getInterpretation(classes);
295
296 var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
297 var newModel = dseAdapter.createObject();
298 var newModelId = newModel.get(0);
299 var newClass1 = dseAdapter.createObject();
300 var newClass1Id = newClass1.get(0);
301 var newClass2 = dseAdapter.createObject();
302 var newClass2Id = newClass2.get(0);
303 var newField = dseAdapter.createObject();
304 var newFieldId = newField.get(0);
305
306 classModelInterpretation.put(newModel, true);
307 classElementInterpretation.put(newClass1, true);
308 classElementInterpretation.put(newClass2, true);
309 featureInterpretation.put(newField, true);
310 classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
311 classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
312 featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
313
314 queryEngine.flushChanges();
315
316 assertResults(Map.of(
317 Tuple.of(newModelId, newClass1Id), true,
318 Tuple.of(newModelId, newClass2Id), true
319 ), deleteEmptyClassRule.getAllActivationsAsResultSet());
320
321
322 deleteEmptyClassRule.fireActivation(Tuple.of(0, 1));
323
324 assertResults(Map.of(
325 Tuple.of(newModelId, newClass1Id), false,
326 Tuple.of(newModelId, newClass2Id), true
327 ), deleteEmptyClassRule.getAllActivationsAsResultSet());
328 }
329
330 @Test
331 void randomFireTest() {
332 var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
333 (builder, model, c) -> builder.clause((f) -> List.of(
334 classModelView.call(model),
335 classElementView.call(c),
336 featuresView.call(model, f),
337 not(encapsulatesView.call(c, f))
338 )));
339
340 TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass0",
341 deleteEmptyClassPrecondition,
342 (model) -> {
343 var classesInterpretation = model.getInterpretation(classes);
344 var classElementInterpretation = model.getInterpretation(classElement);
345 return ((Tuple activation) -> {
346 var modelElement = activation.get(0);
347 var classElement = activation.get(1);
348
349 classesInterpretation.put(Tuple.of(modelElement, classElement), false);
350 classElementInterpretation.put(Tuple.of(classElement), false);
351 });
352 },
353 0L);
354
355 var store = ModelStore.builder()
356 .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
357 .with(ViatraModelQueryAdapter.builder()
358 .queries(deleteEmptyClassPrecondition))
359 .with(DesignSpaceExplorationAdapter.builder()
360 .strategy(new DepthFirstStrategy().withDepthLimit(0)))
361 .build();
362
363 var model = store.createEmptyModel();
364 var queryEngine = model.getAdapter(ModelQueryAdapter.class);
365 deleteEmptyClassRule.prepare(model, queryEngine);
366
367 var classModelInterpretation = model.getInterpretation(classModel);
368 var classElementInterpretation = model.getInterpretation(classElement);
369 var featureInterpretation = model.getInterpretation(feature);
370 var featuresInterpretation = model.getInterpretation(features);
371 var classesInterpretation = model.getInterpretation(classes);
372
373 var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
374 var newModel = dseAdapter.createObject();
375 var newModelId = newModel.get(0);
376 var newClass1 = dseAdapter.createObject();
377 var newClass1Id = newClass1.get(0);
378 var newClass2 = dseAdapter.createObject();
379 var newClass2Id = newClass2.get(0);
380 var newField = dseAdapter.createObject();
381 var newFieldId = newField.get(0);
382
383 classModelInterpretation.put(newModel, true);
384 classElementInterpretation.put(newClass1, true);
385 classElementInterpretation.put(newClass2, true);
386 featureInterpretation.put(newField, true);
387 classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
388 classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
389 featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
390
391 queryEngine.flushChanges();
392
393 assertResults(Map.of(
394 Tuple.of(newModelId, newClass1Id), true,
395 Tuple.of(newModelId, newClass2Id), true
396 ), deleteEmptyClassRule.getAllActivationsAsResultSet());
397
398 deleteEmptyClassRule.fireRandomActivation();
399
400 assertResults(Map.of(
401 Tuple.of(newModelId, newClass1Id), true,
402 Tuple.of(newModelId, newClass2Id), false
403 ), deleteEmptyClassRule.getAllActivationsAsResultSet());
404
405 deleteEmptyClassRule.fireRandomActivation();
406
407 assertResults(Map.of(
408 Tuple.of(newModelId, newClass1Id), false,
409 Tuple.of(newModelId, newClass2Id), false
410 ), deleteEmptyClassRule.getAllActivationsAsResultSet());
411
412 }
413}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-06-25 09:25:58 +0000