test: ModelSemantics test framework

19 files changed, 907 insertions, 2 deletions

diff --git a/subprojects/generator/build.gradle.kts b/subprojects/generator/build.gradle.kts
index e5cf1bc4..7fa4b849 100644
--- a/subprojects/generator/build.gradle.kts
+++ b/subprojects/generator/build.gradle.kts
@@ -6,6 +6,7 @@
 
 plugins {
         id("tools.refinery.gradle.java-library")
+        id("tools.refinery.gradle.java-test-fixtures")
 }
 
 mavenArtifact {
@@ -15,5 +16,6 @@ mavenArtifact {
 dependencies {
         api(project(":refinery-language-semantics"))
         implementation(project(":refinery-store-query-interpreter"))
+        testFixturesImplementation(libs.junit.api)
         testImplementation(testFixtures(project(":refinery-language")))
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
index 43427502..b624a507 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
@@ -12,14 +12,22 @@ import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
 
+import java.util.Collection;
 import java.util.Set;
 
 public final class ModelSemanticsFactory extends ModelFacadeFactory<ModelSemanticsFactory> {
+        private boolean withCandidateInterpretations;
+
         @Override
         protected ModelSemanticsFactory getSelf() {
                 return this;
         }
 
+        public ModelSemanticsFactory withCandidateInterpretations(boolean withCandidateInterpretations) {
+                this.withCandidateInterpretations = withCandidateInterpretations;
+                return this;
+        }
+
         public ModelSemantics createSemantics(Problem problem) {
                 var semantics = tryCreateSemantics(problem);
                 semantics.getPropagationResult().throwIfRejected();
@@ -36,9 +44,14 @@ public final class ModelSemanticsFactory extends ModelFacadeFactory<ModelSemanti
                                 .with(PropagationAdapter.builder()
                                                 .throwOnFatalRejection(false))
                                 .with(ReasoningAdapter.builder()
-                                                .requiredInterpretations(Set.of(Concreteness.PARTIAL)));
+                                                .requiredInterpretations(getRequiredInterpretations()));
                 initializer.configureStoreBuilder(storeBuilder, isKeepNonExistingObjects());
                 var store = storeBuilder.build();
                 return new ModelSemantics(initializer.getProblemTrace(), store, initializer.getModelSeed());
         }
+
+        private Collection<Concreteness> getRequiredInterpretations() {
+                return withCandidateInterpretations ? Set.of(Concreteness.PARTIAL, Concreteness.CANDIDATE) :
+                                Set.of(Concreteness.PARTIAL);
+        }
 }
diff --git a/subprojects/generator/src/test/java/tools/refinery/generator/FileBasedSemanticsTest.java b/subprojects/generator/src/test/java/tools/refinery/generator/FileBasedSemanticsTest.java
new file mode 100644
index 00000000..6fdcf3fd
--- /dev/null
+++ b/subprojects/generator/src/test/java/tools/refinery/generator/FileBasedSemanticsTest.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.DynamicNode;
+import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.api.extension.ExtendWith;
+import tools.refinery.generator.tests.DynamicTestLoader;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+
+import java.util.stream.Stream;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class FileBasedSemanticsTest {
+        @Inject
+        private DynamicTestLoader loader;
+
+        @TestFactory
+        Stream<DynamicNode> fileBasedTests() {
+                return loader.fromClasspath(getClass(),
+                                "abstractTypeHierarchy.problem",
+                                "typeHierarchy.problem"
+                );
+        }
+}
diff --git a/subprojects/generator/src/test/resources/tools/refinery/generator/abstractTypeHierarchy.problem b/subprojects/generator/src/test/resources/tools/refinery/generator/abstractTypeHierarchy.problem
new file mode 100644
index 00000000..559c077d
--- /dev/null
+++ b/subprojects/generator/src/test/resources/tools/refinery/generator/abstractTypeHierarchy.problem
@@ -0,0 +1,47 @@
+% SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+%
+% SPDX-License-Identifier: EPL-2.0
+
+abstract class A.
+
+class B extends A.
+
+class C extends A.
+
+class D extends A.
+
+% TEST: negative subclasses
+!B(a).
+!C(a).
+!D(a).
+% EXPECT:
+!A(a).
+
+% TEST: infer subclass by exclusion
+A(a).
+!B(a).
+!C(a).
+% EXPECT:
+D(a).
+
+% TEST: candidate rounding
+A(a).
+% EXPECT EXACTLY:
+?B(a).
+?C(a).
+?D(a).
+% EXPECT CANDIDATE:
+B(a).
+!C(a).
+!D(a).
+
+% TEST: candidate rounding with exclusion
+A(a).
+!B(a).
+% EXPECT EXACTLY:
+?C(a).
+?D(a).
+% EXPECT CANDIDATE:
+!B(a).
+C(a).
+!D(a).
diff --git a/subprojects/generator/src/test/resources/tools/refinery/generator/typeHierarchy.problem b/subprojects/generator/src/test/resources/tools/refinery/generator/typeHierarchy.problem
new file mode 100644
index 00000000..2d297067
--- /dev/null
+++ b/subprojects/generator/src/test/resources/tools/refinery/generator/typeHierarchy.problem
@@ -0,0 +1,24 @@
+% SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+%
+% SPDX-License-Identifier: EPL-2.0
+
+class A.
+
+class B extends A.
+
+% TEST: positive subclass
+B(b).
+% EXPECT:
+A(b).
+
+% TEST: negative superclass
+!A(b).
+% EXPECT:
+!B(b).
+
+% TEST WITH ERRORS: inconsistent type
+!A(b).
+B(b).
+% EXPECT:
+A(b): error.
+B(b): error.
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/DynamicTestLoader.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/DynamicTestLoader.java
new file mode 100644
index 00000000..4a93e77a
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/DynamicTestLoader.java
@@ -0,0 +1,143 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import org.junit.jupiter.api.DynamicNode;
+import org.junit.jupiter.api.function.Executable;
+import tools.refinery.generator.ModelSemanticsFactory;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.DynamicContainer.dynamicContainer;
+import static org.junit.jupiter.api.DynamicTest.dynamicTest;
+
+public class DynamicTestLoader {
+        @Inject
+        private SemanticsTestLoader testLoader;
+
+        @Inject
+        private Provider<ModelSemanticsFactory> semanticsFactoryProvider;
+
+        public Stream<DynamicNode> fromClasspath(Class<?> klass, String name) {
+                URL url;
+                URI uri;
+                try {
+                        url = safeGetResource(klass, name);
+                        uri = url.toURI();
+                } catch (RuntimeException | URISyntaxException e) {
+                        return Stream.of(createErrorNode(name, null, e));
+                }
+                SemanticsTest test;
+                try {
+                        test = loadFromUrl(uri, url);
+                } catch (IOException | RuntimeException e) {
+                        return Stream.of(createErrorNode(name, uri, e));
+                }
+                return createDynamicNodes(uri, test);
+        }
+
+        public Stream<DynamicNode> fromClasspath(Class<?> klass, String... names) {
+                return fromClasspath(klass, Stream.of(names));
+        }
+
+        public Stream<DynamicNode> fromClasspath(Class<?> klass, Stream<String> names) {
+                return names.map(name -> nodeFromClasspath(klass, name));
+        }
+
+        private DynamicNode nodeFromClasspath(Class<?> klass, String name) {
+                URL url;
+                URI uri;
+                try {
+                        url = safeGetResource(klass, name);
+                        uri = url.toURI();
+                } catch (RuntimeException | URISyntaxException e) {
+                        return createErrorNode(name, null, e);
+                }
+                SemanticsTest test;
+                try {
+                        test = loadFromUrl(uri, url);
+                } catch (IOException | RuntimeException e) {
+                        return createErrorNode(name, uri, e);
+                }
+                return createDynamicNode(name, uri, test);
+        }
+
+        private static URL safeGetResource(Class<?> klass, String name) {
+                var url = klass.getResource(name);
+                if (url == null) {
+                        throw new IllegalStateException("Test resource %s was not found.".formatted(name));
+                }
+                return url;
+        }
+
+        private SemanticsTest loadFromUrl(URI uri, URL url) throws IOException {
+                var eclipseUri = org.eclipse.emf.common.util.URI.createURI(uri.toString());
+                try (var inputStream = url.openStream()) {
+                        return testLoader.loadStream(inputStream, eclipseUri);
+                }
+        }
+
+        public Stream<DynamicNode> fromString(String problem) {
+                SemanticsTest test;
+                try {
+                        test = testLoader.loadString(problem);
+                } catch (RuntimeException e) {
+                        return Stream.of(createErrorNode("<string>", null, e));
+                }
+                return createDynamicNodes(null, test);
+        }
+
+        private DynamicNode createDynamicNode(String name, URI uri, SemanticsTest test) {
+                var testCases = test.testCases();
+                if (testCases.size() == 1 && testCases.getFirst().name() == null) {
+                        var testCase = testCases.getFirst();
+                        return dynamicTest(name, uri, asExecutable(testCase));
+                }
+                var children = createDynamicNodes(uri, test);
+                return dynamicContainer(name, uri, children);
+        }
+
+        private Stream<DynamicNode> createDynamicNodes(URI uri, SemanticsTest test) {
+                var testCases = test.testCases();
+                var children = new ArrayList<DynamicNode>();
+                int testCaseCount = testCases.size();
+                for (int i = 0; i < testCaseCount; i++) {
+                        var testCase = testCases.get(i);
+                        var testCaseName = testCase.name();
+                        if (testCaseName == null) {
+                                testCaseName = "[%d]".formatted(i);
+                        }
+                        children.add(dynamicTest(testCaseName, uri, asExecutable(testCase)));
+                }
+                return children.stream();
+        }
+
+        private Executable asExecutable(SemanticsTestCase testCase) {
+                return () -> testCase.execute(semanticsFactoryProvider.get());
+        }
+
+        private DynamicNode createErrorNode(String name, URI uri, Throwable cause) {
+                var messageBuilder = new StringBuilder();
+                messageBuilder.append("Error while reading test '").append(name).append("'");
+                if (uri != null) {
+                        messageBuilder.append(" from ").append(uri);
+                }
+                if (cause != null) {
+                        messageBuilder.append(": ").append(cause.getMessage());
+                }
+                var message = messageBuilder.toString();
+                return dynamicTest(name, uri, () ->     {
+                        throw new RuntimeException(message, cause);
+                });
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsExpectation.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsExpectation.java
new file mode 100644
index 00000000..5cc28cd9
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsExpectation.java
@@ -0,0 +1,117 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests;
+
+import org.eclipse.core.runtime.AssertionFailedException;
+import tools.refinery.generator.FilteredInterpretation;
+import tools.refinery.generator.ModelSemantics;
+import tools.refinery.language.model.problem.Assertion;
+import tools.refinery.language.model.problem.Node;
+import tools.refinery.language.model.problem.NodeAssertionArgument;
+import tools.refinery.language.model.problem.WildcardAssertionArgument;
+import tools.refinery.language.semantics.SemanticsUtils;
+import tools.refinery.logic.term.truthvalue.TruthValue;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.tuple.Tuple;
+
+public record SemanticsExpectation(Assertion assertion, Concreteness concreteness, boolean exact,
+                                                                   int lineNumber, String description, String source) {
+        public void execute(ModelSemantics semantics) {
+                var trace = semantics.getProblemTrace();
+                var symbol = trace.getPartialRelation(assertion.getRelation());
+                var reasoningAdapter = semantics.getModel().getAdapter(ReasoningAdapter.class);
+                var interpretation = reasoningAdapter.getPartialInterpretation(concreteness, symbol);
+                var existsInterpretation = reasoningAdapter.getPartialInterpretation(concreteness,
+                                ReasoningAdapter.EXISTS_SYMBOL);
+                var filteredInterpretation = new FilteredInterpretation<>(interpretation, existsInterpretation);
+
+                var arguments = assertion.getArguments();
+                int arity = arguments.size();
+                var nodeIds = new int[arity];
+                boolean wildcard = false;
+                for (int i = 0; i < arity; i++) {
+                        var argument = arguments.get(i);
+                        switch (argument) {
+                        case NodeAssertionArgument nodeAssertionArgument -> {
+                                var nodeOrVariable = nodeAssertionArgument.getNode();
+                                if (!(nodeOrVariable instanceof Node node)) {
+                                        throw new IllegalArgumentException("Invalid Node: " + nodeOrVariable);
+                                }
+                                nodeIds[i] = trace.getNodeId(node);
+                        }
+                        case WildcardAssertionArgument ignored -> {
+                                nodeIds[i] = 1;
+                                wildcard = true;
+                        }
+                        default -> throw new IllegalArgumentException("Invalid AssertionArgument: " + argument);
+                        }
+                }
+
+                var expectedValue = SemanticsUtils.getTruthValue(assertion.getValue());
+                if (wildcard) {
+                        checkWildcard(filteredInterpretation, nodeIds, expectedValue);
+                } else {
+                        checkSingle(filteredInterpretation, nodeIds, expectedValue);
+                }
+        }
+
+
+        private void checkSingle(PartialInterpretation<TruthValue, Boolean> interpretation, int[] nodeIds,
+                                                         TruthValue expectedValue) {
+                var tuple = Tuple.of(nodeIds);
+                var actual = interpretation.get(tuple);
+                if (assertionFailed(expectedValue, actual)) {
+                        throw new AssertionFailedException(getMessage(actual));
+                }
+        }
+
+        private void checkWildcard(PartialInterpretation<TruthValue, Boolean> interpretation, int[] nodeIds,
+                                                           TruthValue expectedValue) {
+                int arity = nodeIds.length;
+                var cursor = interpretation.getAll();
+                while (cursor.move()) {
+                        var key = cursor.getKey();
+                        boolean matches = true;
+                        for (int i = 0; matches && i < arity; i++) {
+                                int nodeId = nodeIds[i];
+                                if (nodeId >= 0 && key.get(i) != nodeId) {
+                                        matches = false;
+                                }
+                        }
+                        if (matches && assertionFailed(expectedValue, cursor.getValue())) {
+                                throw new AssertionFailedException(getMessage(null));
+                        }
+                }
+        }
+
+        private boolean assertionFailed(TruthValue expectedValue, TruthValue actual) {
+                return !(exact ? actual.equals(expectedValue) : actual.isRefinementOf(expectedValue));
+        }
+
+        private String getMessage(TruthValue actual) {
+                var messageBuilder = new StringBuilder();
+                messageBuilder.append("EXPECT");
+                if (concreteness == Concreteness.CANDIDATE) {
+                        messageBuilder.append(" CANDIDATE");
+                }
+                if (exact) {
+                        messageBuilder.append(" EXACTLY");
+                }
+                messageBuilder.append(" ").append(source);
+                if (description != null) {
+                        messageBuilder.append(" (").append(description).append(")");
+                }
+                if (actual == null) {
+                        messageBuilder.append(" failed");
+                } else {
+                        messageBuilder.append(" was ").append(actual).append(" instead");
+                }
+                messageBuilder.append(" in line ").append(lineNumber);
+                return messageBuilder.toString();
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTest.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTest.java
new file mode 100644
index 00000000..6a34f6ef
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTest.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests;
+
+import tools.refinery.generator.ModelSemanticsFactory;
+
+import java.util.List;
+
+public record SemanticsTest(List<SemanticsTestCase> testCases) {
+        public void execute(ModelSemanticsFactory semanticsFactory) {
+                for (var testCase : testCases) {
+                        testCase.execute(semanticsFactory);
+                }
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestBuilder.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestBuilder.java
new file mode 100644
index 00000000..2d40af5f
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestBuilder.java
@@ -0,0 +1,93 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests;
+
+import org.eclipse.emf.common.util.URI;
+import tools.refinery.generator.ProblemLoader;
+import tools.refinery.generator.tests.internal.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+
+class SemanticsTestBuilder implements ChunkAcceptor {
+        private final Pattern LINE_PATTERN = Pattern.compile("^.+$", Pattern.MULTILINE);
+
+        private final ProblemLoader problemLoader;
+        private final URI uri;
+        private final StringBuilder commonBuilder = new StringBuilder();
+        private final List<SemanticsTestCase> testCases = new ArrayList<>();
+        private SemanticsTestCaseBuilder testCaseBuilder;
+        private boolean singleTestMode;
+
+        public SemanticsTestBuilder(ProblemLoader problemLoader, URI uri) {
+                this.problemLoader = problemLoader;
+                this.uri = uri;
+        }
+
+        @Override
+        public void acceptChunk(ChunkHeader header, String body) {
+                switch (header) {
+                case CommonHeader ignored -> {
+                        if (testCaseBuilder != null) {
+                                throw new IllegalStateException("Can't accept common test code after the first test case.");
+                        }
+                        commonBuilder.append(body);
+                }
+                case TestCaseHeader testCaseHeader -> {
+                        if (singleTestMode) {
+                                throw new IllegalStateException("Can't accept TEST chunk after an EXPECT chunk.");
+                        }
+                        acceptTestCase(testCaseHeader, body);
+                        appendEmptyLines(body);
+                }
+                case ExpectationHeader expectationHeader -> {
+                        if (testCaseBuilder == null) {
+                                acceptTestCase(new TestCaseHeader(false, null), null);
+                                singleTestMode = true;
+                        }
+                        testCaseBuilder.acceptExpectation(expectationHeader, body);
+                        appendEmptyLines(body);
+                }
+                default -> throw new IllegalArgumentException("Unknown ChunkHeader: " + header);
+                }
+        }
+
+        private void appendEmptyLines(String body) {
+                if (singleTestMode) {
+                        return;
+                }
+                var placeholder = LINE_PATTERN.matcher(body).replaceAll("");
+                commonBuilder.append(placeholder);
+        }
+
+        private void acceptTestCase(TestCaseHeader header, String body) {
+                if (testCaseBuilder != null) {
+                        testCases.add(testCaseBuilder.build());
+                }
+                var problemStringBuilder = new StringBuilder(commonBuilder);
+                if (body != null) {
+                        problemStringBuilder.append(body);
+                }
+                testCaseBuilder = new SemanticsTestCaseBuilder(header, problemStringBuilder, problemLoader, uri);
+        }
+
+        @Override
+        public void acceptEnd() {
+                if (testCaseBuilder == null) {
+                        throw new IllegalStateException("Test file contained no TEST or EXPECT chunks.");
+                }
+                testCases.add(testCaseBuilder.build());
+        }
+
+        public SemanticsTest build() {
+                if (testCases.isEmpty()) {
+                        throw new IllegalStateException("No test cases.");
+                }
+                return new SemanticsTest(Collections.unmodifiableList(testCases));
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestCase.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestCase.java
new file mode 100644
index 00000000..952924e2
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestCase.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests;
+
+import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
+import org.eclipse.collections.api.map.primitive.IntObjectMap;
+import org.eclipse.core.runtime.AssertionFailedException;
+import tools.refinery.generator.ModelSemantics;
+import tools.refinery.generator.ModelSemanticsFactory;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.semantics.ProblemTrace;
+import tools.refinery.logic.term.truthvalue.TruthValue;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+public record SemanticsTestCase(String name, boolean allowErrors, Problem problem,
+                                                                List<SemanticsExpectation> expectations) {
+        public void execute(ModelSemanticsFactory semanticsFactory) {
+                semanticsFactory.withCandidateInterpretations(needsCandidateInterpretations());
+                var semantics = semanticsFactory.createSemantics(problem);
+                if (!allowErrors) {
+                        checkNoErrors(semantics);
+                }
+                for (var expectation : expectations) {
+                        expectation.execute(semantics);
+                }
+        }
+
+        public boolean needsCandidateInterpretations() {
+                for (var expectation : expectations) {
+                        if (expectation.concreteness() == Concreteness.CANDIDATE) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        private void checkNoErrors(ModelSemantics semantics) {
+                boolean hasError = false;
+                var errorsBuilder = new StringBuilder("Errors found in partial model:\n\n");
+                var trace = semantics.getProblemTrace();
+                IntObjectMap<String> nodeNames = null;
+                for (var symbol : trace.getRelationTrace().values()) {
+                        var interpretation = semantics.getPartialInterpretation(symbol);
+                        var cursor = interpretation.getAll();
+                        while (cursor.move()) {
+                                if (!cursor.getValue().isError()) {
+                                        continue;
+                                }
+                                hasError = true;
+                                if (nodeNames == null) {
+                                        nodeNames = getNodeNames(trace);
+                                }
+                                appendError(symbol, errorsBuilder, cursor, nodeNames);
+                        }
+                }
+                if (hasError) {
+                        throw new AssertionFailedException(errorsBuilder.toString());
+                }
+        }
+
+        private IntObjectMap<String> getNodeNames(ProblemTrace trace) {
+                var nodeNames = IntObjectMaps.mutable.<String>empty();
+                trace.getNodeTrace().forEachKeyValue((node, i) -> {
+                        var name = node.getName();
+                        if (name != null) {
+                                nodeNames.put(i, name);
+                        }
+                });
+                return nodeNames;
+        }
+
+        private static void appendError(PartialRelation symbol, StringBuilder errorsBuilder,
+                                                                        Cursor<Tuple, TruthValue> cursor, IntObjectMap<String> nodeNames) {
+                errorsBuilder.append('\t').append(symbol.name()).append("(");
+                var key = cursor.getKey();
+                int arity = key.getSize();
+                for (int i = 0; i < arity; i++) {
+                        if (i > 0) {
+                                errorsBuilder.append(", ");
+                        }
+                        int nodeId = key.get(i);
+                        var name = nodeNames.get(nodeId);
+                        if (name == null) {
+                                errorsBuilder.append("::").append(i);
+                        } else {
+                                errorsBuilder.append(name);
+                        }
+                }
+                errorsBuilder.append("): error.\n");
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestCaseBuilder.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestCaseBuilder.java
new file mode 100644
index 00000000..cd163cb8
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestCaseBuilder.java
@@ -0,0 +1,95 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
+import tools.refinery.generator.ProblemLoader;
+import tools.refinery.generator.tests.internal.ExpectationHeader;
+import tools.refinery.generator.tests.internal.TestCaseHeader;
+import tools.refinery.language.model.problem.Assertion;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.Statement;
+
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+
+class SemanticsTestCaseBuilder {
+        private final TestCaseHeader testCaseHeader;
+        private final StringBuilder stringBuilder;
+        private final ProblemLoader problemLoader;
+        private final URI uri;
+        private final Deque<ExpectationHeader> expectationsDeque = new ArrayDeque<>();
+
+        public SemanticsTestCaseBuilder(TestCaseHeader testCaseHeader, StringBuilder stringBuilder,
+                                                                        ProblemLoader problemLoader, URI uri) {
+                this.testCaseHeader = testCaseHeader;
+                this.stringBuilder = stringBuilder;
+                this.problemLoader = problemLoader;
+                this.uri = uri;
+        }
+
+        public void acceptExpectation(ExpectationHeader header, String body) {
+                stringBuilder.append(body);
+                expectationsDeque.addLast(header);
+        }
+
+        public SemanticsTestCase build() {
+                Problem problem;
+                try {
+                        problem = problemLoader.loadString(stringBuilder.toString(), uri);
+                } catch (IOException e) {
+                        throw new IllegalStateException("Failed to parse problem: " + uri, e);
+                }
+                if (expectationsDeque.isEmpty() && testCaseHeader.allowErrors()) {
+                        throw new IllegalStateException("Test has no EXPECT chunks.");
+                }
+                var statements = problem.getStatements();
+                int initialStatementCount = 0;
+                ExpectationHeader currentHeader = null;
+                var expectations = new ArrayList<SemanticsExpectation>();
+                for (var statement : statements) {
+                        var node = NodeModelUtils.findActualNodeFor(statement);
+                        if (node == null) {
+                                throw new IllegalStateException("No node for statement: " + statement);
+                        }
+                        var nextHeader = expectationsDeque.peekFirst();
+                        if (nextHeader != null && node.getStartLine() >= nextHeader.startLine()) {
+                                currentHeader = nextHeader;
+                                expectationsDeque.removeFirst();
+                        }
+                        if (currentHeader == null) {
+                                initialStatementCount++;
+                        } else {
+                                var expectation = createExpectation(currentHeader, statement, node);
+                                expectations.add(expectation);
+                        }
+                }
+                int statementCount = statements.size();
+                if (statementCount > initialStatementCount) {
+                        statements.subList(initialStatementCount, statementCount).clear();
+                }
+                return new SemanticsTestCase(testCaseHeader.name(), testCaseHeader.allowErrors(), problem,
+                                Collections.unmodifiableList(expectations));
+        }
+
+        private static SemanticsExpectation createExpectation(ExpectationHeader header, Statement statement,
+                                                                                                                  INode node) {
+                if (!(statement instanceof Assertion assertion)) {
+                        throw new IllegalArgumentException("Only assertions are supported in EXPECT chunks, got %s instead."
+                                        .formatted(statement.eClass().getName()));
+                }
+                if (assertion.isDefault()) {
+                        throw new IllegalArgumentException("Default assertions are not supported in EXPECT chunks.");
+                }
+                return new SemanticsExpectation(assertion, header.concreteness(), header.exact(),
+                                node.getStartLine(), header.description(), NodeModelUtils.getTokenText(node).strip());
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestLoader.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestLoader.java
new file mode 100644
index 00000000..82c8deb1
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/SemanticsTestLoader.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.URI;
+import tools.refinery.generator.ProblemLoader;
+import tools.refinery.generator.tests.internal.ProblemSplitter;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+
+public class SemanticsTestLoader {
+        @Inject
+        private ProblemSplitter problemSplitter;
+
+        @Inject
+        private ProblemLoader problemLoader;
+
+        public SemanticsTestLoader extraPath(String path) {
+                problemLoader.extraPath(Path.of(path));
+                return this;
+        }
+
+        public SemanticsTestLoader extraPath(Path path) {
+                problemLoader.extraPath(path);
+                return this;
+        }
+
+        public SemanticsTest loadString(String problemString, URI uri) {
+                var builder = new SemanticsTestBuilder(problemLoader, uri);
+                problemSplitter.transformProblem(problemString, builder);
+                return builder.build();
+        }
+
+        public SemanticsTest loadString(String problemString) {
+                return loadString(problemString, null);
+        }
+
+        public SemanticsTest loadStream(InputStream inputStream, URI uri) throws IOException {
+                byte[] bytes;
+                try (var outputStream = new ByteArrayOutputStream()) {
+                        inputStream.transferTo(outputStream);
+                        bytes = outputStream.toByteArray();
+                }
+                var problemString = new String(bytes, StandardCharsets.UTF_8);
+                return loadString(problemString, uri);
+        }
+
+        public SemanticsTest loadStream(InputStream inputStream) throws IOException {
+                return loadStream(inputStream, null);
+        }
+
+        public SemanticsTest loadFile(File file) throws IOException {
+                var uri = URI.createFileURI(file.getAbsolutePath());
+                try (var inputStream = new FileInputStream(file)) {
+                        return loadStream(inputStream, uri);
+                }
+        }
+
+        public SemanticsTest loadFile(String filePath) throws IOException {
+                var uri = URI.createFileURI(filePath);
+                try (var inputStream = new FileInputStream(filePath)) {
+                        return loadStream(inputStream, uri);
+                }
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ChunkAcceptor.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ChunkAcceptor.java
new file mode 100644
index 00000000..cf867b19
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ChunkAcceptor.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests.internal;
+
+public interface ChunkAcceptor {
+        void acceptChunk(ChunkHeader header, String body);
+
+        void acceptEnd();
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ChunkHeader.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ChunkHeader.java
new file mode 100644
index 00000000..a69668ec
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ChunkHeader.java
@@ -0,0 +1,9 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests.internal;
+
+public sealed interface ChunkHeader permits CommonHeader, TestCaseHeader, ExpectationHeader {
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/CommonHeader.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/CommonHeader.java
new file mode 100644
index 00000000..bec9e748
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/CommonHeader.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests.internal;
+
+public final class CommonHeader implements ChunkHeader {
+        public static final CommonHeader INSTANCE = new CommonHeader();
+
+        private CommonHeader() {
+        }
+
+        @Override
+        public String toString() {
+                return getClass().getSimpleName() + "[]";
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ExpectationHeader.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ExpectationHeader.java
new file mode 100644
index 00000000..00608739
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ExpectationHeader.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests.internal;
+
+import tools.refinery.store.reasoning.literal.Concreteness;
+
+public record ExpectationHeader(Concreteness concreteness, boolean exact, String description,
+                                                                int startLine) implements ChunkHeader {
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ProblemSplitter.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ProblemSplitter.java
new file mode 100644
index 00000000..33a0ca6e
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/ProblemSplitter.java
@@ -0,0 +1,92 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests.internal;
+
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Provider;
+import com.google.inject.Singleton;
+import com.google.inject.name.Named;
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CommonToken;
+import org.antlr.runtime.Token;
+import org.antlr.runtime.TokenSource;
+import org.eclipse.xtext.parser.antlr.Lexer;
+import tools.refinery.language.parser.antlr.ProblemTokenSource;
+import tools.refinery.language.parser.antlr.lexer.InternalProblemLexer;
+import tools.refinery.store.reasoning.literal.Concreteness;
+
+import java.util.regex.Pattern;
+
+@Singleton
+public class ProblemSplitter {
+        private static final String COMMENT_PREFIX = "(//|%)\\s*";
+
+        private static final Pattern TEST_CASE_PATTERN = Pattern.compile(COMMENT_PREFIX +
+                        "TEST(?<allowErrors>\\s+WITH\\s+ERRORS)?(\\s*:\\s*(?<name>\\S.*)?)?");
+
+        private static final Pattern EXPECTATION_PATTERN = Pattern.compile(COMMENT_PREFIX +
+                        "EXPECT(?<candidate>\\s+CANDIDATE)?(?<exact>\\s+EXACTLY)?(\\s*:\\s*(?<description>\\S.*)?)?");
+
+        @Inject
+        @Named("org.eclipse.xtext.parser.antlr.Lexer.RUNTIME")
+        private Provider<Lexer> lexerProvider;
+
+        @Inject
+        private Injector injector;
+
+        public void transformProblem(String problemString, ChunkAcceptor acceptor) {
+                var tokenSource = getTokenSource(problemString);
+                Token token = tokenSource.nextToken();
+                ChunkHeader lastHeader = CommonHeader.INSTANCE;
+                int lastStartIndex = 0;
+                do {
+                        if (token.getType() == InternalProblemLexer.RULE_SL_COMMENT) {
+                                if (!(token instanceof CommonToken commonToken)) {
+                                        throw new IllegalStateException("Unexpected token: " + token);
+                                }
+                                var header = parseHeader(token);
+                                if (header != null) {
+                                        int startIndex = commonToken.getStartIndex();
+                                        var body = problemString.substring(lastStartIndex, startIndex);
+                                        acceptor.acceptChunk(lastHeader, body);
+                                        lastHeader = header;
+                                        lastStartIndex = startIndex;
+                                }
+                        }
+                        token = tokenSource.nextToken();
+                } while (token != null && token.getType() != Token.EOF);
+                acceptor.acceptChunk(lastHeader, problemString.substring(lastStartIndex));
+                acceptor.acceptEnd();
+        }
+
+        private TokenSource getTokenSource(String problemString) {
+                var charStream = new ANTLRStringStream(problemString);
+                var lexer = lexerProvider.get();
+                lexer.setCharStream(charStream);
+                var tokenSource = new ProblemTokenSource(lexer);
+                injector.injectMembers(tokenSource);
+                return tokenSource;
+        }
+
+        private ChunkHeader parseHeader(Token token) {
+                var headerText = token.getText().strip();
+                var testCaseMatcher = TEST_CASE_PATTERN.matcher(headerText);
+                if (testCaseMatcher.matches()) {
+                        boolean allowErrors = testCaseMatcher.group("allowErrors") != null;
+                        return new TestCaseHeader(allowErrors, testCaseMatcher.group("name"));
+                }
+                var expectationMatcher = EXPECTATION_PATTERN.matcher(headerText);
+                if (expectationMatcher.matches()) {
+                        var concreteness = expectationMatcher.group("candidate") == null ? Concreteness.PARTIAL :
+                                        Concreteness.CANDIDATE;
+                        var exact = expectationMatcher.group("exact") != null;
+                        return new ExpectationHeader(concreteness, exact, expectationMatcher.group("description"),
+                    token.getLine());
+                }
+                return null;
+        }
+}
diff --git a/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/TestCaseHeader.java b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/TestCaseHeader.java
new file mode 100644
index 00000000..505b4769
--- /dev/null
+++ b/subprojects/generator/src/testFixtures/java/tools/refinery/generator/tests/internal/TestCaseHeader.java
@@ -0,0 +1,9 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.tests.internal;
+
+public record TestCaseHeader(boolean allowErrors, String name) implements ChunkHeader {
+}
diff --git a/subprojects/logic/src/main/java/tools/refinery/logic/term/truthvalue/TruthValue.java b/subprojects/logic/src/main/java/tools/refinery/logic/term/truthvalue/TruthValue.java
index 59bdeab3..671e1a05 100644
--- a/subprojects/logic/src/main/java/tools/refinery/logic/term/truthvalue/TruthValue.java
+++ b/subprojects/logic/src/main/java/tools/refinery/logic/term/truthvalue/TruthValue.java
@@ -50,7 +50,6 @@ public enum TruthValue implements AbstractValue<TruthValue, Boolean> {
                 return !isError();
         }
 
-
         public boolean isComplete() {
                 return this != UNKNOWN;
         }