From a3f1e6872f4f768d14899a1e70bbdc14f32e478d Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sun, 20 Aug 2023 19:41:32 +0200 Subject: feat: improve semantics error reporting Also makes model seeds cancellable to reduce server load during semantic analysis. --- .../store/query/InvalidQueryException.java | 23 +++++ .../store/query/dnf/ClausePostProcessor.java | 9 +- .../java/tools/refinery/store/query/dnf/Dnf.java | 3 +- .../tools/refinery/store/query/dnf/DnfBuilder.java | 88 +--------------- .../refinery/store/query/dnf/DnfPostProcessor.java | 112 +++++++++++++++++++++ .../store/query/dnf/FunctionalDependency.java | 4 +- .../refinery/store/query/dnf/FunctionalQuery.java | 5 +- .../store/query/dnf/InvalidClauseException.java | 35 +++++++ .../refinery/store/query/dnf/RelationalQuery.java | 3 +- .../store/query/literal/AbstractCallLiteral.java | 5 +- .../store/query/literal/AbstractCountLiteral.java | 5 +- .../store/query/literal/AggregationLiteral.java | 13 +-- .../store/query/literal/AssignLiteral.java | 7 +- .../refinery/store/query/literal/CallLiteral.java | 7 +- .../refinery/store/query/literal/CallPolarity.java | 4 +- .../refinery/store/query/literal/CheckLiteral.java | 5 +- .../store/query/literal/EquivalenceLiteral.java | 3 +- .../literal/RepresentativeElectionLiteral.java | 9 +- .../refinery/store/query/term/AnyDataVariable.java | 3 +- .../refinery/store/query/term/BinaryTerm.java | 5 +- .../refinery/store/query/term/ConstantTerm.java | 3 +- .../refinery/store/query/term/DataVariable.java | 5 +- .../refinery/store/query/term/NodeVariable.java | 3 +- .../store/query/term/ParameterDirection.java | 4 +- .../tools/refinery/store/query/term/UnaryTerm.java | 3 +- .../refinery/store/query/view/FilteredView.java | 3 +- .../store/query/dnf/DnfToDefinitionStringTest.java | 4 +- .../store/query/dnf/TopologicalSortTest.java | 7 +- .../store/query/dnf/VariableDirectionTest.java | 10 +- .../query/literal/AggregationLiteralTest.java | 13 +-- 30 files changed, 261 insertions(+), 142 deletions(-) create mode 100644 subprojects/store-query/src/main/java/tools/refinery/store/query/InvalidQueryException.java create mode 100644 subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfPostProcessor.java create mode 100644 subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/InvalidClauseException.java (limited to 'subprojects/store-query/src') diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/InvalidQueryException.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/InvalidQueryException.java new file mode 100644 index 00000000..c39277a0 --- /dev/null +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/InvalidQueryException.java @@ -0,0 +1,23 @@ +/* + * SPDX-FileCopyrightText: 2023 The Refinery Authors + * + * SPDX-License-Identifier: EPL-2.0 + */ +package tools.refinery.store.query; + +public class InvalidQueryException extends RuntimeException { + public InvalidQueryException() { + } + + public InvalidQueryException(String message) { + super(message); + } + + public InvalidQueryException(String message, Throwable cause) { + super(message, cause); + } + + public InvalidQueryException(Throwable cause) { + super(cause); + } +} diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java index 5d77b9aa..8800a155 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java @@ -7,6 +7,7 @@ package tools.refinery.store.query.dnf; import org.jetbrains.annotations.NotNull; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.literal.*; import tools.refinery.store.query.substitution.MapBasedSubstitution; import tools.refinery.store.query.substitution.StatelessSubstitution; @@ -160,7 +161,7 @@ class ClausePostProcessor { // Inputs count as positive, because they are already bound when we evaluate literals. positiveVariables.add(variable); } else if (!existentiallyQuantifiedVariables.contains(variable)) { - throw new IllegalArgumentException("Unbound %s parameter %s" + throw new InvalidQueryException("Unbound %s parameter %s" .formatted(ParameterDirection.OUT, variable)); } } @@ -172,7 +173,7 @@ class ClausePostProcessor { var representative = pair.getKey(); if (!positiveVariables.contains(representative)) { var variableSet = pair.getValue(); - throw new IllegalArgumentException("Variables %s were merged by equivalence but are not bound" + throw new InvalidQueryException("Variables %s were merged by equivalence but are not bound" .formatted(variableSet)); } } @@ -184,7 +185,7 @@ class ClausePostProcessor { for (var variable : literal.getPrivateVariables(positiveVariables)) { var oldLiteral = negativeVariablesMap.put(variable, literal); if (oldLiteral != null) { - throw new IllegalArgumentException("Unbound variable %s appears in multiple literals %s and %s" + throw new InvalidQueryException("Unbound variable %s appears in multiple literals %s and %s" .formatted(variable, oldLiteral, literal)); } } @@ -206,7 +207,7 @@ class ClausePostProcessor { variable.addToSortedLiterals(); } if (!variableToLiteralInputMap.isEmpty()) { - throw new IllegalArgumentException("Unbound input variables %s" + throw new InvalidQueryException("Unbound input variables %s" .formatted(variableToLiteralInputMap.keySet())); } } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java index 55f1aae5..86a1b6b2 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.dnf; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.DnfEqualityChecker; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.SubstitutingLiteralEqualityHelper; @@ -55,7 +56,7 @@ public final class Dnf implements Constraint { FunctionalDependency functionalDependency) { for (var variable : toValidate) { if (!parameterSet.contains(variable)) { - throw new IllegalArgumentException( + throw new InvalidQueryException( "Variable %s of functional dependency %s does not appear in the parameter list %s" .formatted(variable, functionalDependency, symbolicParameters)); } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java index 0538427f..0f9fd366 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java @@ -5,10 +5,8 @@ */ package tools.refinery.store.query.dnf; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.dnf.callback.*; -import tools.refinery.store.query.equality.DnfEqualityChecker; -import tools.refinery.store.query.equality.SubstitutingLiteralEqualityHelper; -import tools.refinery.store.query.equality.SubstitutingLiteralHashCodeHelper; import tools.refinery.store.query.literal.Literal; import tools.refinery.store.query.term.*; @@ -100,7 +98,7 @@ public final class DnfBuilder { public DnfBuilder symbolicParameter(SymbolicParameter symbolicParameter) { var variable = symbolicParameter.getVariable(); if (!parameterVariables.add(variable)) { - throw new IllegalArgumentException("Variable %s is already on the parameter list %s" + throw new InvalidQueryException("Variable %s is already on the parameter list %s" .formatted(variable, parameters)); } parameters.add(symbolicParameter); @@ -218,88 +216,10 @@ public final class DnfBuilder { } public Dnf build() { - var postProcessedClauses = postProcessClauses(); + var postProcessor = new DnfPostProcessor(parameters, clauses); + var postProcessedClauses = postProcessor.postProcessClauses(); return new Dnf(name, Collections.unmodifiableList(parameters), Collections.unmodifiableList(functionalDependencies), Collections.unmodifiableList(postProcessedClauses)); } - - private List postProcessClauses() { - var parameterInfoMap = getParameterInfoMap(); - var postProcessedClauses = new LinkedHashSet(clauses.size()); - for (var literals : clauses) { - var postProcessor = new ClausePostProcessor(parameterInfoMap, literals); - var result = postProcessor.postProcessClause(); - if (result instanceof ClausePostProcessor.ClauseResult clauseResult) { - postProcessedClauses.add(new CanonicalClause(clauseResult.clause())); - } else if (result instanceof ClausePostProcessor.ConstantResult constantResult) { - switch (constantResult) { - case ALWAYS_TRUE -> { - var inputVariables = getInputVariables(); - return List.of(new DnfClause(inputVariables, List.of())); - } - case ALWAYS_FALSE -> { - // Skip this clause because it can never match. - } - default -> throw new IllegalStateException("Unexpected ClausePostProcessor.ConstantResult: " + - constantResult); - } - } else { - throw new IllegalStateException("Unexpected ClausePostProcessor.Result: " + result); - } - } - return postProcessedClauses.stream().map(CanonicalClause::getDnfClause).toList(); - } - - private Map getParameterInfoMap() { - var mutableParameterInfoMap = new LinkedHashMap(); - int arity = parameters.size(); - for (int i = 0; i < arity; i++) { - var parameter = parameters.get(i); - mutableParameterInfoMap.put(parameter.getVariable(), - new ClausePostProcessor.ParameterInfo(parameter.getDirection(), i)); - } - return Collections.unmodifiableMap(mutableParameterInfoMap); - } - - private Set getInputVariables() { - var inputParameters = new LinkedHashSet(); - for (var parameter : parameters) { - if (parameter.getDirection() == ParameterDirection.IN) { - inputParameters.add(parameter.getVariable()); - } - } - return Collections.unmodifiableSet(inputParameters); - } - - private class CanonicalClause { - private final DnfClause dnfClause; - - public CanonicalClause(DnfClause dnfClause) { - this.dnfClause = dnfClause; - } - - public DnfClause getDnfClause() { - return dnfClause; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null || getClass() != obj.getClass()) { - return false; - } - var otherCanonicalClause = (CanonicalClause) obj; - var helper = new SubstitutingLiteralEqualityHelper(DnfEqualityChecker.DEFAULT, parameters, parameters); - return dnfClause.equalsWithSubstitution(helper, otherCanonicalClause.dnfClause); - } - - @Override - public int hashCode() { - var helper = new SubstitutingLiteralHashCodeHelper(parameters); - return dnfClause.hashCodeWithSubstitution(helper); - } - } } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfPostProcessor.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfPostProcessor.java new file mode 100644 index 00000000..50236642 --- /dev/null +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfPostProcessor.java @@ -0,0 +1,112 @@ +/* + * SPDX-FileCopyrightText: 2023 The Refinery Authors + * + * SPDX-License-Identifier: EPL-2.0 + */ +package tools.refinery.store.query.dnf; + +import tools.refinery.store.query.InvalidQueryException; +import tools.refinery.store.query.equality.DnfEqualityChecker; +import tools.refinery.store.query.equality.SubstitutingLiteralEqualityHelper; +import tools.refinery.store.query.equality.SubstitutingLiteralHashCodeHelper; +import tools.refinery.store.query.literal.Literal; +import tools.refinery.store.query.term.ParameterDirection; +import tools.refinery.store.query.term.Variable; + +import java.util.*; + +class DnfPostProcessor { + private final List parameters; + private final List> clauses; + + public DnfPostProcessor(List parameters, List> clauses) { + this.parameters = parameters; + this.clauses = clauses; + } + + public List postProcessClauses() { + var parameterInfoMap = getParameterInfoMap(); + var postProcessedClauses = new LinkedHashSet(clauses.size()); + int index = 0; + for (var literals : clauses) { + var postProcessor = new ClausePostProcessor(parameterInfoMap, literals); + ClausePostProcessor.Result result; + try { + result = postProcessor.postProcessClause(); + } catch (InvalidQueryException e) { + throw new InvalidClauseException(index, e); + } + if (result instanceof ClausePostProcessor.ClauseResult clauseResult) { + postProcessedClauses.add(new CanonicalClause(clauseResult.clause())); + } else if (result instanceof ClausePostProcessor.ConstantResult constantResult) { + switch (constantResult) { + case ALWAYS_TRUE -> { + var inputVariables = getInputVariables(); + return List.of(new DnfClause(inputVariables, List.of())); + } + case ALWAYS_FALSE -> { + // Skip this clause because it can never match. + } + default -> throw new IllegalStateException("Unexpected ClausePostProcessor.ConstantResult: " + + constantResult); + } + } else { + throw new IllegalStateException("Unexpected ClausePostProcessor.Result: " + result); + } + index++; + } + return postProcessedClauses.stream().map(CanonicalClause::getDnfClause).toList(); + } + + private Map getParameterInfoMap() { + var mutableParameterInfoMap = new LinkedHashMap(); + int arity = parameters.size(); + for (int i = 0; i < arity; i++) { + var parameter = parameters.get(i); + mutableParameterInfoMap.put(parameter.getVariable(), + new ClausePostProcessor.ParameterInfo(parameter.getDirection(), i)); + } + return Collections.unmodifiableMap(mutableParameterInfoMap); + } + + private Set getInputVariables() { + var inputParameters = new LinkedHashSet(); + for (var parameter : parameters) { + if (parameter.getDirection() == ParameterDirection.IN) { + inputParameters.add(parameter.getVariable()); + } + } + return Collections.unmodifiableSet(inputParameters); + } + + private class CanonicalClause { + private final DnfClause dnfClause; + + public CanonicalClause(DnfClause dnfClause) { + this.dnfClause = dnfClause; + } + + public DnfClause getDnfClause() { + return dnfClause; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null || getClass() != obj.getClass()) { + return false; + } + var otherCanonicalClause = (CanonicalClause) obj; + var helper = new SubstitutingLiteralEqualityHelper(DnfEqualityChecker.DEFAULT, parameters, parameters); + return dnfClause.equalsWithSubstitution(helper, otherCanonicalClause.dnfClause); + } + + @Override + public int hashCode() { + var helper = new SubstitutingLiteralHashCodeHelper(parameters); + return dnfClause.hashCodeWithSubstitution(helper); + } + } +} diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java index b00b2cb7..aef07ee3 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java @@ -5,6 +5,8 @@ */ package tools.refinery.store.query.dnf; +import tools.refinery.store.query.InvalidQueryException; + import java.util.HashSet; import java.util.Set; @@ -13,7 +15,7 @@ public record FunctionalDependency(Set forEach, Set unique) { var uniqueForEach = new HashSet<>(unique); uniqueForEach.retainAll(forEach); if (!uniqueForEach.isEmpty()) { - throw new IllegalArgumentException("Variables %s appear on both sides of the functional dependency" + throw new InvalidQueryException("Variables %s appear on both sides of the functional dependency" .formatted(uniqueForEach)); } } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java index bf7651ad..225f6844 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.dnf; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.literal.CallPolarity; import tools.refinery.store.query.term.Aggregator; import tools.refinery.store.query.term.AssignedValue; @@ -26,14 +27,14 @@ public final class FunctionalQuery extends Query { var parameter = parameters.get(i); var parameterType = parameter.tryGetType(); if (parameterType.isPresent()) { - throw new IllegalArgumentException("Expected parameter %s of %s to be a node variable, got %s instead" + throw new InvalidQueryException("Expected parameter %s of %s to be a node variable, got %s instead" .formatted(parameter, dnf, parameterType.get().getName())); } } var outputParameter = parameters.get(outputIndex); var outputParameterType = outputParameter.tryGetType(); if (outputParameterType.isEmpty() || !outputParameterType.get().equals(type)) { - throw new IllegalArgumentException("Expected parameter %s of %s to be %s, but got %s instead".formatted( + throw new InvalidQueryException("Expected parameter %s of %s to be %s, but got %s instead".formatted( outputParameter, dnf, type, outputParameterType.map(Class::getName).orElse("node"))); } this.type = type; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/InvalidClauseException.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/InvalidClauseException.java new file mode 100644 index 00000000..747574b9 --- /dev/null +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/InvalidClauseException.java @@ -0,0 +1,35 @@ +/* + * SPDX-FileCopyrightText: 2023 The Refinery Authors + * + * SPDX-License-Identifier: EPL-2.0 + */ +package tools.refinery.store.query.dnf; + +import tools.refinery.store.query.InvalidQueryException; + +public class InvalidClauseException extends InvalidQueryException { + private final int clauseIndex; + + public InvalidClauseException(int clauseIndex) { + this.clauseIndex = clauseIndex; + } + + public InvalidClauseException(int clauseIndex, String message) { + super(message); + this.clauseIndex = clauseIndex; + } + + public InvalidClauseException(int clauseIndex, String message, Throwable cause) { + super(message, cause); + this.clauseIndex = clauseIndex; + } + + public InvalidClauseException(int clauseIndex, Throwable cause) { + super(cause); + this.clauseIndex = clauseIndex; + } + + public int getClauseIndex() { + return clauseIndex; + } +} diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java index 618fb595..98f71e11 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.dnf; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.literal.CallLiteral; import tools.refinery.store.query.literal.CallPolarity; import tools.refinery.store.query.term.AssignedValue; @@ -19,7 +20,7 @@ public final class RelationalQuery extends Query { for (var parameter : dnf.getSymbolicParameters()) { var parameterType = parameter.tryGetType(); if (parameterType.isPresent()) { - throw new IllegalArgumentException("Expected parameter %s of %s to be a node variable, got %s instead" + throw new InvalidQueryException("Expected parameter %s of %s to be a node variable, got %s instead" .formatted(parameter, dnf, parameterType.get().getName())); } } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java index 3722f7f9..0e99d441 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.literal; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -27,7 +28,7 @@ public abstract class AbstractCallLiteral extends AbstractLiteral { protected AbstractCallLiteral(Constraint target, List arguments) { int arity = target.arity(); if (arguments.size() != arity) { - throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.name(), + throw new InvalidQueryException("%s needs %d arguments, but got %s".formatted(target.name(), target.arity(), arguments.size())); } this.target = target; @@ -39,7 +40,7 @@ public abstract class AbstractCallLiteral extends AbstractLiteral { var argument = arguments.get(i); var parameter = parameters.get(i); if (!parameter.isAssignable(argument)) { - throw new IllegalArgumentException("Argument %d of %s is not assignable to parameter %s" + throw new InvalidQueryException("Argument %d of %s is not assignable to parameter %s" .formatted(i, target, parameter)); } switch (parameter.getDirection()) { diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java index 75f4bd49..9bb572c0 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.literal; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.term.ConstantTerm; @@ -26,11 +27,11 @@ public abstract class AbstractCountLiteral extends AbstractCallLiteral { List arguments) { super(target, arguments); if (!resultVariable.getType().equals(resultType)) { - throw new IllegalArgumentException("Count result variable %s must be of type %s, got %s instead".formatted( + throw new InvalidQueryException("Count result variable %s must be of type %s, got %s instead".formatted( resultVariable, resultType, resultVariable.getType().getName())); } if (arguments.contains(resultVariable)) { - throw new IllegalArgumentException("Count result variable %s must not appear in the argument list" + throw new InvalidQueryException("Count result variable %s must not appear in the argument list" .formatted(resultVariable)); } this.resultType = resultType; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java index a2f8e009..e3acfacc 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.literal; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -26,19 +27,19 @@ public class AggregationLiteral extends AbstractCallLiteral { DataVariable inputVariable, Constraint target, List arguments) { super(target, arguments); if (!inputVariable.getType().equals(aggregator.getInputType())) { - throw new IllegalArgumentException("Input variable %s must of type %s, got %s instead".formatted( + throw new InvalidQueryException("Input variable %s must of type %s, got %s instead".formatted( inputVariable, aggregator.getInputType().getName(), inputVariable.getType().getName())); } if (!getArgumentsOfDirection(ParameterDirection.OUT).contains(inputVariable)) { - throw new IllegalArgumentException("Input variable %s must be bound with direction %s in the argument list" + throw new InvalidQueryException("Input variable %s must be bound with direction %s in the argument list" .formatted(inputVariable, ParameterDirection.OUT)); } if (!resultVariable.getType().equals(aggregator.getResultType())) { - throw new IllegalArgumentException("Result variable %s must of type %s, got %s instead".formatted( + throw new InvalidQueryException("Result variable %s must of type %s, got %s instead".formatted( resultVariable, aggregator.getResultType().getName(), resultVariable.getType().getName())); } if (arguments.contains(resultVariable)) { - throw new IllegalArgumentException("Result variable %s must not appear in the argument list".formatted( + throw new InvalidQueryException("Result variable %s must not appear in the argument list".formatted( resultVariable)); } this.resultVariable = resultVariable; @@ -66,7 +67,7 @@ public class AggregationLiteral extends AbstractCallLiteral { @Override public Set getInputVariables(Set positiveVariablesInClause) { if (positiveVariablesInClause.contains(inputVariable)) { - throw new IllegalArgumentException("Aggregation variable %s must not be bound".formatted(inputVariable)); + throw new InvalidQueryException("Aggregation variable %s must not be bound".formatted(inputVariable)); } return super.getInputVariables(positiveVariablesInClause); } @@ -80,7 +81,7 @@ public class AggregationLiteral extends AbstractCallLiteral { yield emptyValue == null ? BooleanLiteral.FALSE : resultVariable.assign(new ConstantTerm<>(resultVariable.getType(), emptyValue)); } - case ALWAYS_TRUE -> throw new IllegalArgumentException("Trying to aggregate over an infinite set"); + case ALWAYS_TRUE -> throw new InvalidQueryException("Trying to aggregate over an infinite set"); case NOT_REDUCIBLE -> this; }; } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java index d8a4b494..dadf487f 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.literal; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -16,18 +17,20 @@ import java.util.Collections; import java.util.Objects; import java.util.Set; +// {@link Object#equals(Object)} is implemented by {@link AbstractLiteral}. +@SuppressWarnings("squid:S2160") public class AssignLiteral extends AbstractLiteral { private final DataVariable variable; private final Term term; public AssignLiteral(DataVariable variable, Term term) { if (!term.getType().equals(variable.getType())) { - throw new IllegalArgumentException("Term %s must be of type %s, got %s instead".formatted( + throw new InvalidQueryException("Term %s must be of type %s, got %s instead".formatted( term, variable.getType().getName(), term.getType().getName())); } var inputVariables = term.getInputVariables(); if (inputVariables.contains(variable)) { - throw new IllegalArgumentException("Result variable %s must not appear in the term %s".formatted( + throw new InvalidQueryException("Result variable %s must not appear in the term %s".formatted( variable, term)); } this.variable = variable; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java index 1b05943d..2d0e4e97 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.literal; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -25,14 +26,14 @@ public final class CallLiteral extends AbstractCallLiteral implements CanNegate< int arity = target.arity(); if (polarity.isTransitive()) { if (arity != 2) { - throw new IllegalArgumentException("Transitive closures can only take binary relations"); + throw new InvalidQueryException("Transitive closures can only take binary relations"); } if (parameters.get(0).isDataVariable() || parameters.get(1).isDataVariable()) { - throw new IllegalArgumentException("Transitive closures can only be computed over nodes"); + throw new InvalidQueryException("Transitive closures can only be computed over nodes"); } if (parameters.get(0).getDirection() != ParameterDirection.OUT || parameters.get(1).getDirection() != ParameterDirection.OUT) { - throw new IllegalArgumentException("Transitive closures cannot take input parameters"); + throw new InvalidQueryException("Transitive closures cannot take input parameters"); } } this.polarity = polarity; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java index ca70b0fd..716c7109 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java @@ -5,6 +5,8 @@ */ package tools.refinery.store.query.literal; +import tools.refinery.store.query.InvalidQueryException; + public enum CallPolarity { POSITIVE(true, false), NEGATIVE(false, false), @@ -31,7 +33,7 @@ public enum CallPolarity { return switch (this) { case POSITIVE -> NEGATIVE; case NEGATIVE -> POSITIVE; - case TRANSITIVE -> throw new IllegalArgumentException("Transitive polarity cannot be negated"); + case TRANSITIVE -> throw new InvalidQueryException("Transitive polarity cannot be negated"); }; } } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java index 1271183a..dfedd2cb 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.literal; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -18,12 +19,14 @@ import java.util.Collections; import java.util.Objects; import java.util.Set; +// {@link Object#equals(Object)} is implemented by {@link AbstractLiteral}. +@SuppressWarnings("squid:S2160") public class CheckLiteral extends AbstractLiteral implements CanNegate { private final Term term; public CheckLiteral(Term term) { if (!term.getType().equals(Boolean.class)) { - throw new IllegalArgumentException("Term %s must be of type %s, got %s instead".formatted( + throw new InvalidQueryException("Term %s must be of type %s, got %s instead".formatted( term, Boolean.class.getName(), term.getType().getName())); } this.term = term; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java index 9a0c22d1..7343f709 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.literal; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -22,7 +23,7 @@ public final class EquivalenceLiteral extends AbstractLiteral implements CanNega public EquivalenceLiteral(boolean positive, Variable left, Variable right) { if (!left.tryGetType().equals(right.tryGetType())) { - throw new IllegalArgumentException("Variables %s and %s of different type cannot be equivalent" + throw new InvalidQueryException("Variables %s and %s of different type cannot be equivalent" .formatted(left, right)); } this.positive = positive; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java index f6545f9f..f7323947 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.literal; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -32,14 +33,14 @@ public class RepresentativeElectionLiteral extends AbstractCallLiteral { var parameters = target.getParameters(); int arity = target.arity(); if (arity != 2) { - throw new IllegalArgumentException("SCCs can only take binary relations"); + throw new InvalidQueryException("SCCs can only take binary relations"); } if (parameters.get(0).isDataVariable() || parameters.get(1).isDataVariable()) { - throw new IllegalArgumentException("SCCs can only be computed over nodes"); + throw new InvalidQueryException("SCCs can only be computed over nodes"); } if (parameters.get(0).getDirection() != ParameterDirection.OUT || parameters.get(1).getDirection() != ParameterDirection.OUT) { - throw new IllegalArgumentException("SCCs cannot take input parameters"); + throw new InvalidQueryException("SCCs cannot take input parameters"); } } @@ -72,7 +73,7 @@ public class RepresentativeElectionLiteral extends AbstractCallLiteral { var reduction = getTarget().getReduction(); return switch (reduction) { case ALWAYS_FALSE -> BooleanLiteral.FALSE; - case ALWAYS_TRUE -> throw new IllegalArgumentException( + case ALWAYS_TRUE -> throw new InvalidQueryException( "Trying to elect representatives over an infinite set"); case NOT_REDUCIBLE -> this; }; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java index 4d88051b..3801bc11 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.term; import org.jetbrains.annotations.Nullable; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import java.util.Optional; @@ -33,7 +34,7 @@ public abstract sealed class AnyDataVariable extends Variable implements AnyTerm @Override public NodeVariable asNodeVariable() { - throw new IllegalStateException("%s is a data variable".formatted(this)); + throw new InvalidQueryException("%s is a data variable".formatted(this)); } @Override diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java index 09c86db6..cdbf592a 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.term; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -26,11 +27,11 @@ public abstract class BinaryTerm extends AbstractTerm { protected BinaryTerm(Class type, Class leftType, Class rightType, Term left, Term right) { super(type); if (!left.getType().equals(leftType)) { - throw new IllegalArgumentException("Expected left %s to be of type %s, got %s instead".formatted( + throw new InvalidQueryException("Expected left %s to be of type %s, got %s instead".formatted( left, leftType.getName(), left.getType().getName())); } if (!right.getType().equals(rightType)) { - throw new IllegalArgumentException("Expected right %s to be of type %s, got %s instead".formatted( + throw new InvalidQueryException("Expected right %s to be of type %s, got %s instead".formatted( right, rightType.getName(), right.getType().getName())); } this.leftType = leftType; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java index e722c84f..415ae286 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.term; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -21,7 +22,7 @@ public final class ConstantTerm extends AbstractTerm { public ConstantTerm(Class type, T value) { super(type); if (value != null && !type.isInstance(value)) { - throw new IllegalArgumentException("Value %s is not an instance of %s".formatted(value, type.getName())); + throw new InvalidQueryException("Value %s is not an instance of %s".formatted(value, type.getName())); } this.value = value; } diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java index 9b62e545..2206b522 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.term; import org.jetbrains.annotations.Nullable; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.literal.EquivalenceLiteral; @@ -41,8 +42,8 @@ public final class DataVariable extends AnyDataVariable implements Term { @Override public DataVariable asDataVariable(Class newType) { if (!getType().equals(newType)) { - throw new IllegalStateException("%s is not of type %s but of type %s".formatted(this, newType.getName(), - getType().getName())); + throw new InvalidQueryException("%s is not of type %s but of type %s" + .formatted(this, newType.getName(), getType().getName())); } @SuppressWarnings("unchecked") var result = (DataVariable) this; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java index 2f9c8bf1..53c32e20 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.term; import org.jetbrains.annotations.Nullable; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.literal.ConstantLiteral; import tools.refinery.store.query.literal.EquivalenceLiteral; @@ -48,7 +49,7 @@ public final class NodeVariable extends Variable { @Override public DataVariable asDataVariable(Class type) { - throw new IllegalStateException("%s is a node variable".formatted(this)); + throw new InvalidQueryException("%s is a node variable".formatted(this)); } @Override diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java index cd0739be..da83f3c3 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java @@ -6,8 +6,8 @@ package tools.refinery.store.query.term; public enum ParameterDirection { - OUT("@Out"), - IN("@In"); + OUT("out"), + IN("in"); private final String name; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java index 6451ea00..a464ece5 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.term; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.equality.LiteralEqualityHelper; import tools.refinery.store.query.equality.LiteralHashCodeHelper; import tools.refinery.store.query.substitution.Substitution; @@ -22,7 +23,7 @@ public abstract class UnaryTerm extends AbstractTerm { protected UnaryTerm(Class type, Class bodyType, Term body) { super(type); if (!body.getType().equals(bodyType)) { - throw new IllegalArgumentException("Expected body %s to be of type %s, got %s instead".formatted(body, + throw new InvalidQueryException("Expected body %s to be of type %s, got %s instead".formatted(body, bodyType.getName(), body.getType().getName())); } this.bodyType = bodyType; diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java index abae6e5c..924277ed 100644 --- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java +++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java @@ -5,6 +5,7 @@ */ package tools.refinery.store.query.view; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.tuple.Tuple; import tools.refinery.store.representation.Symbol; @@ -66,7 +67,7 @@ public class FilteredView extends TuplePreservingView { // The predicate doesn't need to handle the default value if it is null. } if (matchesDefaultValue) { - throw new IllegalArgumentException("Tuples with default value %s cannot be enumerated in %s" + throw new InvalidQueryException("Tuples with default value %s cannot be enumerated in %s" .formatted(defaultValue, getSymbol())); } } diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java index d75d7f17..12cfaa4e 100644 --- a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java +++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java @@ -50,7 +50,7 @@ class DnfToDefinitionStringTest { var dnf = Dnf.builder("Example").parameter(p, ParameterDirection.IN).clause().build(); assertThat(dnf.toDefinitionString(), is(""" - pred Example(@In p) <-> + pred Example(in p) <-> . """)); } @@ -73,7 +73,7 @@ class DnfToDefinitionStringTest { .build(); assertThat(dnf.toDefinitionString(), is(""" - pred Example(@In p) <-> + pred Example(in p) <-> !(@RelationView("key") friend(p, q)). """)); } diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java index e22dbb21..854bd469 100644 --- a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java +++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java @@ -6,6 +6,7 @@ package tools.refinery.store.query.dnf; import org.junit.jupiter.api.Test; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.term.NodeVariable; import tools.refinery.store.query.term.ParameterDirection; import tools.refinery.store.query.term.Variable; @@ -80,7 +81,7 @@ class TopologicalSortTest { example.call(r, t, q, s), friendView.call(r, t) ); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidQueryException.class, builder::build); } @Test @@ -93,7 +94,7 @@ class TopologicalSortTest { example.call(p, q, r, s), example.call(r, t, q, s) ); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidQueryException.class, builder::build); } @Test @@ -107,6 +108,6 @@ class TopologicalSortTest { example.call(r, t, q, s), example.call(p, q, r, t) ); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidQueryException.class, builder::build); } } diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java index bfeaa447..fc3f5d48 100644 --- a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java +++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java @@ -48,7 +48,7 @@ class VariableDirectionTest { @MethodSource("clausesWithVariableInput") void unboundOutVariableTest(List clause) { var builder = Dnf.builder().parameter(p, ParameterDirection.OUT).clause(clause); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidClauseException.class, builder::build); } @ParameterizedTest @@ -100,7 +100,7 @@ class VariableDirectionTest { var clauseWithEquivalence = new ArrayList(clause); clauseWithEquivalence.add(r.isEquivalent(p)); var builder = Dnf.builder().clause(clauseWithEquivalence); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidClauseException.class, builder::build); } static Stream clausesNotBindingVariable() { @@ -118,7 +118,7 @@ class VariableDirectionTest { @MethodSource("literalsWithPrivateVariable") void unboundTwicePrivateVariableTest(Literal literal) { var builder = Dnf.builder().clause(not(personView.call(p)), literal); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidClauseException.class, builder::build); } @ParameterizedTest @@ -126,7 +126,7 @@ class VariableDirectionTest { void unboundTwiceByEquivalencePrivateVariableTest(Literal literal) { var r = Variable.of("r"); var builder = Dnf.builder().clause(not(personView.call(r)), r.isEquivalent(p), literal); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidClauseException.class, builder::build); } static Stream literalsWithPrivateVariable() { @@ -159,7 +159,7 @@ class VariableDirectionTest { @MethodSource("literalsWithRequiredVariableInput") void unboundPrivateVariableTest(Literal literal) { var builder = Dnf.builder().clause(literal); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidClauseException.class, builder::build); } @ParameterizedTest diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java index 35910e08..ddd57e96 100644 --- a/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java +++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java @@ -7,15 +7,16 @@ package tools.refinery.store.query.literal; import org.junit.jupiter.api.Test; import tools.refinery.store.query.Constraint; +import tools.refinery.store.query.InvalidQueryException; import tools.refinery.store.query.dnf.Dnf; +import tools.refinery.store.query.dnf.InvalidClauseException; import tools.refinery.store.query.term.*; import java.util.List; import java.util.Set; import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.*; import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertThrows; import static tools.refinery.store.query.literal.Literals.not; @@ -57,13 +58,13 @@ class AggregationLiteralTest { @Test void missingAggregationVariableTest() { var aggregation = fakeConstraint.aggregateBy(y, INT_SUM, p, z); - assertThrows(IllegalArgumentException.class, () -> x.assign(aggregation)); + assertThrows(InvalidQueryException.class, () -> x.assign(aggregation)); } @Test void circularAggregationVariableTest() { var aggregation = fakeConstraint.aggregateBy(x, INT_SUM, p, x); - assertThrows(IllegalArgumentException.class, () -> x.assign(aggregation)); + assertThrows(InvalidQueryException.class, () -> x.assign(aggregation)); } @Test @@ -73,7 +74,7 @@ class AggregationLiteralTest { not(fakeConstraint.call(p, y)), x.assign(fakeConstraint.aggregateBy(y, INT_SUM, p, y)) ); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidClauseException.class, builder::build); } @Test @@ -83,6 +84,6 @@ class AggregationLiteralTest { y.assign(constant(27)), x.assign(fakeConstraint.aggregateBy(y, INT_SUM, p, y)) ); - assertThrows(IllegalArgumentException.class, builder::build); + assertThrows(InvalidClauseException.class, builder::build); } } -- cgit v1.2.3-70-g09d2