refactor: tuples in QueryableModel

9 files changed, 103 insertions, 74 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraTupleLike.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraTupleLike.java
new file mode 100644
index 00000000..46c28434
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraTupleLike.java
@@ -0,0 +1,18 @@
+package tools.refinery.store.query.viatra;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import tools.refinery.store.tuple.Tuple1;
+import tools.refinery.store.tuple.TupleLike;
+
+public record ViatraTupleLike(ITuple wrappedTuple) implements TupleLike {
+        @Override
+        public int getSize() {
+                return wrappedTuple.getSize();
+        }
+
+        @Override
+        public int get(int element) {
+                var wrappedValue = (Tuple1) wrappedTuple.get(element);
+                return wrappedValue.value0();
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java
index be348a63..2c488319 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java
@@ -2,8 +2,9 @@ package tools.refinery.store.query.viatra.internal;
 
 import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher;
 import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
-import org.eclipse.viatra.query.runtime.matchers.tuple.AbstractTuple;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import tools.refinery.store.query.viatra.ViatraTupleLike;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.TupleLike;
 
 import java.util.Optional;
 import java.util.stream.Stream;
@@ -13,39 +14,50 @@ public class RawPatternMatcher extends GenericPatternMatcher {
 
         public RawPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
                 super(specification);
-                this.empty = new Object[specification.getParameterNames().size()];
+                empty = new Object[specification.getParameterNames().size()];
         }
 
         public boolean hasResult() {
-                return hasResult(empty);
+                return backend.hasMatch(empty);
         }
 
-        public boolean hasResult(Object[] parameters) {
-                return this.backend.hasMatch(parameters);
+        public boolean hasResult(Tuple parameters) {
+                return backend.hasMatch(toParametersArray(parameters));
         }
 
-        public Optional<Object[]> oneResult() {
-                return oneResult(empty);
+        public Optional<TupleLike> oneResult() {
+                return backend.getOneArbitraryMatch(empty).map(ViatraTupleLike::new);
         }
 
-        public Optional<Object[]> oneResult(Object[] parameters) {
-                Optional<Tuple> tuple = this.backend.getOneArbitraryMatch(parameters);
-                return tuple.map(AbstractTuple::getElements);
+        public Optional<TupleLike> oneResult(Tuple parameters) {
+                return backend.getOneArbitraryMatch(toParametersArray(parameters)).map(ViatraTupleLike::new);
         }
 
-        public Stream<Object[]> allResults() {
-                return allResults(empty);
+        public Stream<TupleLike> allResults() {
+                return backend.getAllMatches(empty).map(ViatraTupleLike::new);
         }
 
-        public Stream<Object[]> allResults(Object[] parameters) {
-                return this.backend.getAllMatches(parameters).map(AbstractTuple::getElements);
+        public Stream<TupleLike> allResults(Tuple parameters) {
+                return backend.getAllMatches(toParametersArray(parameters)).map(ViatraTupleLike::new);
         }
 
         public int countResults() {
-                return countResults(empty);
+                return backend.countMatches(empty);
         }
 
-        public int countResults(Object[] parameters) {
-                return backend.countMatches(parameters);
+        public int countResults(Tuple parameters) {
+                return backend.countMatches(toParametersArray(parameters));
+        }
+
+        private Object[] toParametersArray(Tuple tuple) {
+                int size = tuple.getSize();
+                var array = new Object[tuple.getSize()];
+                for (int i = 0; i < size; i++) {
+                        var value = tuple.get(i);
+                        if (value >= 0) {
+                                array[i] = Tuple.of(value);
+                        }
+                }
+                return array;
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java
index 8dfa22e0..5ddad67d 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java
@@ -6,7 +6,7 @@ import org.eclipse.viatra.query.runtime.api.scope.IEngineContext;
 import org.eclipse.viatra.query.runtime.api.scope.IIndexingErrorListener;
 import org.eclipse.viatra.query.runtime.api.scope.QueryScope;
 import tools.refinery.store.model.Model;
-import tools.refinery.store.model.Tuple;
+import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
 import tools.refinery.store.query.viatra.internal.context.RelationalEngineContext;
 import tools.refinery.store.query.viatra.internal.viewupdate.ModelUpdateListener;
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java
index 3803702d..1c15e8f9 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java
@@ -8,12 +8,13 @@ import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.DiffCursor;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelDiffCursor;
-import tools.refinery.store.model.Tuple;
 import tools.refinery.store.model.representation.DataRepresentation;
 import tools.refinery.store.model.representation.Relation;
 import tools.refinery.store.query.QueryableModel;
 import tools.refinery.store.query.QueryableModelStore;
 import tools.refinery.store.query.building.DNFPredicate;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.TupleLike;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -124,9 +125,9 @@ public class ViatraQueryableModel implements QueryableModel {
                         return result;
         }
 
-        protected void validateParameters(DNFPredicate predicate, Object[] parameters) {
+        protected void validateParameters(DNFPredicate predicate, Tuple parameters) {
                 int predicateArity = predicate.getVariables().size();
-                int parameterArity = parameters.length;
+                int parameterArity = parameters.getSize();
                 if (parameterArity != predicateArity) {
                         throw new IllegalArgumentException(
                                         "Predicate %s with %d arity called with different number of parameters (%d)"
@@ -140,29 +141,29 @@ public class ViatraQueryableModel implements QueryableModel {
         }
 
         @Override
-        public boolean hasResult(DNFPredicate predicate, Object[] parameters) {
+        public boolean hasResult(DNFPredicate predicate, Tuple parameters) {
                 validateParameters(predicate, parameters);
                 return getMatcher(predicate).hasResult(parameters);
         }
 
         @Override
-        public Optional<Object[]> oneResult(DNFPredicate predicate) {
+        public Optional<TupleLike> oneResult(DNFPredicate predicate) {
                 return getMatcher(predicate).oneResult();
         }
 
         @Override
-        public Optional<Object[]> oneResult(DNFPredicate predicate, Object[] parameters) {
+        public Optional<TupleLike> oneResult(DNFPredicate predicate, Tuple parameters) {
                 validateParameters(predicate, parameters);
                 return getMatcher(predicate).oneResult(parameters);
         }
 
         @Override
-        public Stream<Object[]> allResults(DNFPredicate predicate) {
+        public Stream<TupleLike> allResults(DNFPredicate predicate) {
                 return getMatcher(predicate).allResults();
         }
 
         @Override
-        public Stream<Object[]> allResults(DNFPredicate predicate, Object[] parameters) {
+        public Stream<TupleLike> allResults(DNFPredicate predicate, Tuple parameters) {
                 validateParameters(predicate, parameters);
                 return getMatcher(predicate).allResults(parameters);
         }
@@ -173,7 +174,7 @@ public class ViatraQueryableModel implements QueryableModel {
         }
 
         @Override
-        public int countResults(DNFPredicate predicate, Object[] parameters) {
+        public int countResults(DNFPredicate predicate, Tuple parameters) {
                 validateParameters(predicate, parameters);
                 return getMatcher(predicate).countResults(parameters);
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java
index 5a0da315..1a2fcee7 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java
@@ -3,7 +3,7 @@ package tools.refinery.store.query.viatra.internal.viewupdate;
 import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
-import tools.refinery.store.model.Tuple;
+import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
 import tools.refinery.store.query.view.RelationView;
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java
index e13a9cb8..49f4c501 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java
@@ -1,6 +1,6 @@
 package tools.refinery.store.query.viatra.internal.viewupdate;
 
-import tools.refinery.store.model.Tuple;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java
index 62a10e45..74d0b366 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java
@@ -4,7 +4,7 @@ import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
-import tools.refinery.store.model.Tuple;
+import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.query.view.RelationView;
 
 import java.util.Objects;
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
index 4307ab6b..d6213b02 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
@@ -1,7 +1,6 @@
 package tools.refinery.store.query.viatra.tests;
 
 import org.junit.jupiter.api.Test;
-import tools.refinery.store.model.Tuple;
 import tools.refinery.store.model.representation.Relation;
 import tools.refinery.store.model.representation.TruthValue;
 import tools.refinery.store.query.QueryableModel;
@@ -11,6 +10,8 @@ import tools.refinery.store.query.viatra.ViatraQueryableModelStore;
 import tools.refinery.store.query.view.FilteredRelationView;
 import tools.refinery.store.query.view.KeyOnlyRelationView;
 import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.TupleLike;
 
 import java.util.*;
 import java.util.stream.Stream;
@@ -40,15 +41,16 @@ class QueryTest {
 
                 model.flushChanges();
                 assertEquals(2, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0)), List.of(Tuple.of(1))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0), Tuple.of(1)));
         }
 
         @Test
         void relationConstraintTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -78,16 +80,16 @@ class QueryTest {
 
                 model.flushChanges();
                 assertEquals(3, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0), Tuple.of(1)),
-                                List.of(Tuple.of(1), Tuple.of(0)), List.of(Tuple.of(1), Tuple.of(2))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0, 1), Tuple.of(1, 0), Tuple.of(1, 2)));
         }
 
         @Test
         void andTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -120,23 +122,22 @@ class QueryTest {
                 model.put(friend, Tuple.of(1, 0), TruthValue.TRUE);
                 model.flushChanges();
                 assertEquals(2, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate),
-                                Set.of(List.of(Tuple.of(0), Tuple.of(1)), List.of(Tuple.of(1), Tuple.of(0))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0, 1), Tuple.of(1, 0)));
 
                 model.put(friend, Tuple.of(2, 0), TruthValue.TRUE);
                 model.flushChanges();
                 assertEquals(4, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate),
-                                Set.of(List.of(Tuple.of(0), Tuple.of(1)), List.of(Tuple.of(1), Tuple.of(0)),
-                                                List.of(Tuple.of(0), Tuple.of(2)), List.of(Tuple.of(2), Tuple.of(0))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0, 1), Tuple.of(1, 0), Tuple.of(0, 2),
+                                Tuple.of(2, 0)));
         }
 
         @Test
         void existTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -166,7 +167,7 @@ class QueryTest {
 
                 model.flushChanges();
                 assertEquals(2, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0)), List.of(Tuple.of(1))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0), Tuple.of(1)));
         }
 
         @Test
@@ -176,7 +177,8 @@ class QueryTest {
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<Boolean> animalView = new KeyOnlyRelationView(animal);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -196,8 +198,7 @@ class QueryTest {
                 DNFAnd clause2 = new DNFAnd(Collections.emptySet(),
                                 Arrays.asList(animalRelationAtom1, animalRelationAtom2, friendRelationAtom2));
 
-                // No inter-species friendship
-
+                // No friendship between species
                 DNFPredicate predicate = new DNFPredicate("Or", parameters, Arrays.asList(clause1, clause2));
 
                 QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, animal, friend),
@@ -215,13 +216,12 @@ class QueryTest {
 
                 model.flushChanges();
                 assertEquals(2, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate),
-                                Set.of(List.of(Tuple.of(0), Tuple.of(1)), List.of(Tuple.of(2), Tuple.of(3))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0, 1), Tuple.of(2, 3)));
         }
 
         @Test
         void equalityTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
 
                 Variable p1 = new Variable("p1");
@@ -244,16 +244,16 @@ class QueryTest {
 
                 model.flushChanges();
                 assertEquals(3, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0), Tuple.of(0)),
-                                List.of(Tuple.of(1), Tuple.of(1)), List.of(Tuple.of(2), Tuple.of(2))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0, 0), Tuple.of(1, 1), Tuple.of(2, 2)));
         }
 
         @Test
         void inequalityTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -281,16 +281,16 @@ class QueryTest {
 
                 model.flushChanges();
                 assertEquals(2, model.countResults(predicate));
-                compareMatchSets(model.allResults(predicate),
-                                Set.of(List.of(Tuple.of(0), Tuple.of(1), Tuple.of(2)), List.of(Tuple.of(1), Tuple.of(0), Tuple.of(2))));
+                compareMatchSets(model.allResults(predicate), Set.of(Tuple.of(0, 1, 2), Tuple.of(1, 0, 2)));
         }
 
         @Test
         void patternCallTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -331,10 +331,11 @@ class QueryTest {
 
         @Test
         void negativePatternCallTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -375,10 +376,11 @@ class QueryTest {
 
         @Test
         void transitivePatternCallTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
-                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
 
                 Variable p1 = new Variable("p1");
                 Variable p2 = new Variable("p2");
@@ -415,18 +417,14 @@ class QueryTest {
                 model.flushChanges();
                 assertEquals(3, model.countResults(predicate));
         }
-        static void compareMatchSets(Stream<Object[]> matchSet, Set<List<Tuple>> expected) {
-                Set<List<Tuple>> translatedMatchSet = new HashSet<>();
+
+        static void compareMatchSets(Stream<TupleLike> matchSet, Set<Tuple> expected) {
+                Set<Tuple> translatedMatchSet = new HashSet<>();
                 var iterator = matchSet.iterator();
                 while (iterator.hasNext()) {
                         var element = iterator.next();
-                        List<Tuple> elementToTranslatedMatchSet = new ArrayList<>();
-                        for (Object o : element) {
-                                elementToTranslatedMatchSet.add((Tuple) o);
-                        }
-                        translatedMatchSet.add(elementToTranslatedMatchSet);
+                        translatedMatchSet.add(element.toTuple());
                 }
-
                 assertEquals(expected, translatedMatchSet);
         }
 }
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
index 613d0074..f57bca2b 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
@@ -1,7 +1,7 @@
 package tools.refinery.store.query.viatra.tests;
 
 import org.junit.jupiter.api.Test;
-import tools.refinery.store.model.Tuple;
+import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
 import tools.refinery.store.query.QueryableModel;
 import tools.refinery.store.query.QueryableModelStore;