1 files changed, 90 insertions, 3 deletions

diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
index 25bcb0dc..ce403e3a 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
@@ -5,11 +5,13 @@
  */
 package tools.refinery.store.query.viatra;
 
-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.term.ParameterDirection;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.viatra.tests.QueryEngineTest;
 import tools.refinery.store.query.view.AnySymbolView;
@@ -23,7 +25,7 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.List;
 import java.util.Map;
 
-import static tools.refinery.store.query.literal.Literals.assume;
+import static tools.refinery.store.query.literal.Literals.check;
 import static tools.refinery.store.query.literal.Literals.not;
 import static tools.refinery.store.query.term.int_.IntTerms.constant;
 import static tools.refinery.store.query.term.int_.IntTerms.greaterEq;
@@ -108,6 +110,44 @@ class QueryTest {
         }
 
         @QueryEngineTest
+        void isConstantTest(QueryEvaluationHint hint) {
+                var predicate = Query.of("RelationConstraint", (builder, p1, p2) -> builder.clause(
+                                personView.call(p1),
+                                p1.isConstant(1),
+                                friendMustView.call(p1, p2)
+                ));
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .defaultHint(hint)
+                                                .queries(predicate))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0, 1), false,
+                                Tuple.of(1, 0), true,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 1), false
+                ), predicateResultSet);
+        }
+
+        @QueryEngineTest
         void existTest(QueryEvaluationHint hint) {
                 var predicate = Query.of("Exists", (builder, p1) -> builder.clause((p2) -> List.of(
                                 personView.call(p1),
@@ -312,6 +352,53 @@ class QueryTest {
         }
 
         @QueryEngineTest
+        void patternCallInputArgumentTest(QueryEvaluationHint hint) {
+                var friendPredicate = Dnf.of("Friend", builder -> {
+                        var p1 = builder.parameter("p1", ParameterDirection.IN);
+                        var p2 = builder.parameter("p2", ParameterDirection.IN);
+                        builder.clause(
+                                        personView.call(p1),
+                                        personView.call(p2),
+                                        friendMustView.call(p1, p2)
+                        );
+                });
+                var predicate = Query.of("PositivePatternCall", (builder, p3, p4) -> builder.clause(
+                                personView.call(p3),
+                                personView.call(p4),
+                                friendPredicate.call(p3, p4)
+                ));
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .defaultHint(hint)
+                                                .queries(predicate))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0, 1), true,
+                                Tuple.of(1, 0), true,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 1), false
+                ), predicateResultSet);
+        }
+
+        @QueryEngineTest
         void negativeRelationViewTest(QueryEvaluationHint hint) {
                 var predicate = Query.of("NegativePatternCall", (builder, p1, p2) -> builder.clause(
                                 personView.call(p1),
@@ -652,7 +739,7 @@ class QueryTest {
                 var query = Query.of("Constraint", (builder, p1) -> builder.clause(Integer.class, (x) -> List.of(
                                 personView.call(p1),
                                 ageView.call(p1, x),
-                                assume(greaterEq(x, constant(18)))
+                                check(greaterEq(x, constant(18)))
                 )));
 
                 var store = ModelStore.builder()