Add new transformation rule actions

- TransformationActions can be created after creating the model
- equivalence of actions can be checked

10 files changed, 695 insertions, 0 deletions

diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
index 5aed5298..ab87ddd5 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.dse;
 
 import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.dse.internal.TransformationRule;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.dse.internal.Activation;
 import tools.refinery.store.dse.internal.DesignSpaceExplorationBuilderImpl;
@@ -65,4 +66,6 @@ public interface DesignSpaceExplorationAdapter extends ModelAdapter {
         public void setRandom(long seed);
 
         public List<Version> getSolutions();
+
+        void addTransformationRule(TransformationRule transformationRule);
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
index 220f0b2d..0a5cd7fc 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
@@ -13,6 +13,7 @@ import tools.refinery.store.map.Version;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
 import tools.refinery.store.dse.DesignSpaceExplorationStoreAdapter;
@@ -77,6 +78,12 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
 
         }
 
+        @Override
+        public void addTransformationRule(TransformationRule rule) {
+                transformationRules.add(rule);
+                rule.prepare(model, queryEngine);
+        }
+
         public List<Version> getTrajectory() {
                 return new ArrayList<>(trajectory);
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionSymbol.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionSymbol.java
new file mode 100644
index 00000000..a63f60f0
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionSymbol.java
@@ -0,0 +1,7 @@
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.tuple.Tuple;
+
+public abstract class ActionSymbol implements AtomicAction {
+        public abstract Tuple getValue(Tuple activation);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationSymbol.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationSymbol.java
new file mode 100644
index 00000000..181a5020
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationSymbol.java
@@ -0,0 +1,51 @@
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public class ActivationSymbol extends ActionSymbol {
+
+        private final int index;
+        private Tuple value = null;
+
+        public ActivationSymbol() {
+                this(0);
+        }
+
+        public ActivationSymbol(int index) {
+                this.index = index;
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                value = Tuple.of(activation.get(index));
+        }
+
+        @Override
+        public ActivationSymbol prepare(Model model) {
+                return this;
+        }
+
+        @Override
+        public Tuple getValue(Tuple activation) {
+                return value;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) {
+                        return true;
+                }
+                if (!(obj instanceof ActivationSymbol)) {
+                        return false;
+                }
+        return index == ((ActivationSymbol) obj).index;
+    }
+
+        @Override
+        public int hashCode() {
+                int result = 17;
+                result = 31 * result + Integer.hashCode(index);
+                return result;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java
new file mode 100644
index 00000000..19de644a
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public interface AtomicAction {
+
+        void fire(Tuple activation);
+
+        AtomicAction prepare(Model model);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java
new file mode 100644
index 00000000..589a33c4
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java
@@ -0,0 +1,27 @@
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public class DeleteAction implements AtomicAction {
+
+        private final ActionSymbol symbol;
+        private DesignSpaceExplorationAdapter dseAdapter;
+
+        public DeleteAction(ActionSymbol symbol) {
+                this.symbol = symbol;
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                dseAdapter.deleteObject(symbol.getValue(activation));
+        }
+
+
+        @Override
+        public DeleteAction prepare(Model model) {
+                dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                return this;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java
new file mode 100644
index 00000000..5c02bd45
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java
@@ -0,0 +1,65 @@
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Arrays;
+
+public class InsertAction<T> implements AtomicAction {
+
+        private final Interpretation<T> interpretation;
+        private final T value;
+
+        private final ActionSymbol[] symbols;
+
+        public InsertAction(Interpretation<T> interpretation, T value, ActionSymbol... symbols) {
+                this.interpretation = interpretation;
+                this.value = value;
+                this.symbols = symbols;
+
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                var tuple = Tuple.of(Arrays.stream(symbols).map(symbol -> symbol.getValue(activation).get(0))
+                                .mapToInt(Integer::intValue).toArray());
+
+                interpretation.put(tuple, value);
+        }
+
+        @Override
+        public InsertAction<T> prepare(Model model) {
+                return this;
+        }
+
+        public ActionSymbol[] getSymbols() {
+                return symbols;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) {
+                        return true;
+                }
+                if (!(obj instanceof InsertAction<?> other)) {
+                        return false;
+                }
+                if (symbols.length != other.symbols.length) {
+                        return false;
+                }
+                if (!interpretation.equals(other.interpretation)) {
+                        return false;
+                }
+                return value.equals(other.value);
+        }
+
+        @Override
+        public int hashCode() {
+                int result = 17;
+                result = 31 * result + Integer.hashCode(symbols.length);
+                result = 31 * result + interpretation.hashCode();
+                result = 31 * result + value.hashCode();
+                return result;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemSymbol.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemSymbol.java
new file mode 100644
index 00000000..3c69b9a0
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemSymbol.java
@@ -0,0 +1,40 @@
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+public class NewItemSymbol extends ActionSymbol {
+        private DesignSpaceExplorationAdapter dseAdapter;
+        private Tuple1 value;
+
+        @Override
+        public void fire(Tuple activation) {
+                value = dseAdapter.createObject();
+        }
+
+        @Override
+        public NewItemSymbol prepare(Model model) {
+                dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                return this;
+        }
+
+        @Override
+        public Tuple1 getValue(Tuple activation) {
+                return value;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) {
+                        return true;
+                }
+        return obj instanceof NewItemSymbol;
+    }
+
+        @Override
+        public int hashCode() {
+                return 42;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java
new file mode 100644
index 00000000..2e58a8c4
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java
@@ -0,0 +1,93 @@
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple2;
+
+import java.util.*;
+
+public class TransformationAction {
+        private final List<ActionSymbol> actionSymbols = new ArrayList<>();
+        private final List<InsertAction<?>> insertActions = new ArrayList<>();
+        private boolean configured = false;
+        private final Map<Integer, List<Tuple2>> activationSymbolUsageMap = new LinkedHashMap<>();
+
+        public TransformationAction add(ActionSymbol action) {
+                checkConfigured();
+                actionSymbols.add(action);
+                return this;
+        }
+
+        public TransformationAction add(InsertAction<?> action) {
+                checkConfigured();
+                insertActions.add(action);
+                return this;
+        }
+
+        private void checkConfigured() {
+                if (configured) {
+                        throw new IllegalStateException("Action already configured.");
+                }
+        }
+
+        public TransformationAction prepare(Model model) {
+                for (ActionSymbol action : actionSymbols) {
+                        action.prepare(model);
+                }
+                for (InsertAction<?> action : insertActions) {
+                        action.prepare(model);
+                }
+
+                for (var insertAction : insertActions) {
+                        var actionIndex = insertActions.indexOf(insertAction);
+                        var symbols = insertAction.getSymbols();
+                        for (var i = 0; i < symbols.length; i++) {
+                                var symbolGlobalIndex = actionSymbols.indexOf(symbols[i]);
+                                activationSymbolUsageMap.computeIfAbsent(symbolGlobalIndex, k -> new ArrayList<>());
+                                activationSymbolUsageMap.get(symbolGlobalIndex).add(Tuple.of(actionIndex, i));
+                        }
+                }
+
+                configured = true;
+                return this;
+        }
+
+        public boolean fire(Tuple activation) {
+                for (ActionSymbol action : actionSymbols) {
+                        action.fire(activation);
+                }
+                for (InsertAction<?> action : insertActions) {
+                        action.fire(activation);
+                }
+                return true;
+        }
+
+        // True if Symbols and InsertActions are inserted in same order, ActivationSymbols are equal (they have the same
+        // index for getting the value from the activation Tuple) and InsertActions are equal (they have the same arity
+        // and value to be set).
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) {
+                        return true;
+                }
+                if (!(obj instanceof TransformationAction other)) {
+                        return false;
+                }
+                if (!actionSymbols.equals(other.actionSymbols)) {
+                        return false;
+                }
+                if (!insertActions.equals(other.insertActions)) {
+                        return false;
+                }
+                return this.activationSymbolUsageMap.equals(other.activationSymbolUsageMap);
+
+        }
+
+        @Override
+        public int hashCode() {
+                var result = 17;
+                result = 31 * result + actionSymbols.hashCode();
+                result = 31 * result + insertActions.hashCode();
+                return result;
+        }
+}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/ActionEqualsTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/ActionEqualsTest.java
new file mode 100644
index 00000000..d54bc7d3
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/ActionEqualsTest.java
@@ -0,0 +1,391 @@
+package tools.refinery.store.dse;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.dse.internal.action.*;
+import tools.refinery.store.dse.strategy.DepthFirstStrategy;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+public class ActionEqualsTest {
+
+        private static Model model;
+        private static DesignSpaceExplorationAdapter dseAdapter;
+        private static Symbol<Boolean> type1;
+        private static Symbol<Boolean> type2;
+        private static Symbol<TruthValue> type3;
+        private static Symbol<Boolean> relation1;
+        private static Symbol<Boolean> relation2;
+        private static RelationalQuery precondition1;
+        private static RelationalQuery precondition2;
+
+        @BeforeAll
+        public static void init() {
+                type1 = Symbol.of("type1", 1);
+                type2 = Symbol.of("type2", 1);
+                type3 = Symbol.of("type3", 1, TruthValue.class);
+                relation1 = Symbol.of("relation1", 2);
+                relation2 = Symbol.of("relation2", 2);
+                AnySymbolView type1View = new KeyOnlyView<>(type1);
+                precondition1 = Query.of("CreateClassPrecondition",
+                                (builder, model) -> builder.clause(
+                                                type1View.call(model)
+                                ));
+
+                precondition2 = Query.of("CreateFeaturePrecondition",
+                                (builder, model) -> builder.clause(
+                                                type1View.call(model)
+                                ));
+                var store = ModelStore.builder()
+                                .symbols(type1, type2, type3, relation2, relation1)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(precondition1, precondition2))
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy()))
+                                .build();
+
+
+
+                model = store.createEmptyModel();
+                dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+        }
+
+        @Test
+        void emptyActionEqualsTest() {
+                var action1 = new TransformationAction();
+                var action2 = new TransformationAction();
+                assertEquals(action1, action1);
+                assertEquals(action2, action2);
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void actionTrivialTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void actionIdenticalTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1, activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+
+                var newItemSymbol2 = new NewItemSymbol();
+                var activationSymbol2 = new ActivationSymbol();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(activationSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void actionSymbolGlobalOrderTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1, activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+
+                var newItemSymbol2 = new NewItemSymbol();
+                var activationSymbol2 = new ActivationSymbol();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action2 = new TransformationAction();
+                action2.add(activationSymbol2);
+                action2.add(newItemSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertNotEquals(action1, action2);
+        }
+
+        @Test
+        void actionSymbolInInsertActionOrderTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1, activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+
+                var newItemSymbol2 = new NewItemSymbol();
+                var activationSymbol2 = new ActivationSymbol();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, activationSymbol2,
+                                newItemSymbol2);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(activationSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertNotEquals(action1, action2);
+        }
+
+        @Test
+        void identicalInsertActionInDifferentOrderTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(insertAction1);
+                action2.prepare(model);
+
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void identicalActionAndSymbolDifferentOrderTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var newItemSymbol2 = new NewItemSymbol();
+                var activationSymbol2 = new ActivationSymbol();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(newItemSymbol2);
+                action1.add(activationSymbol1);
+                action1.add(activationSymbol2);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(insertAction1);
+                action2.prepare(model);
+
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void identicalActionAndSymbolMixedOrderTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var newItemSymbol2 = new NewItemSymbol();
+                var activationSymbol2 = new ActivationSymbol();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(newItemSymbol2);
+                action1.add(activationSymbol1);
+                action1.add(activationSymbol2);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(insertAction1);
+                action2.add(newItemSymbol1);
+                action2.add(newItemSymbol2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(activationSymbol2);
+                action2.prepare(model);
+
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void insertActionInterpretationTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type2), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertNotEquals(action1, action2);
+        }
+
+        @Test
+        void insertActionValueTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), false, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertNotEquals(action1, action2);
+        }
+
+        @Test
+        void newItemSymbolDuplicateTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var newItemSymbol2 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol2,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void activationSymbolDuplicateTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol();
+                var activationSymbol2 = new ActivationSymbol();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertEquals(action1, action2);
+        }
+
+        @Test
+        void activationSymbolIndexTest() {
+                var newItemSymbol1 = new NewItemSymbol();
+                var activationSymbol1 = new ActivationSymbol(0);
+                var activationSymbol2 = new ActivationSymbol(1);
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertNotEquals(action1, action2);
+        }
+}