Merge pull request #12 from kris7t/xtext-serialization

Make sure Xtext serialization works

5 files changed, 227 insertions, 12 deletions

diff --git a/language/src/main/java/tools/refinery/language/Problem.xtext b/language/src/main/java/tools/refinery/language/Problem.xtext
index b7562759..26773047 100644
--- a/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -109,12 +109,12 @@ ConstantArgument:
 
 Assertion:
         default?="default"?
-        (relation=[Relation|QualifiedName]
-        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")"
-        ":" value=LogicValue |
-        value=ShortLogicValue?
+        (value=ShortLogicValue?
         relation=[Relation|QualifiedName]
-        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")")
+        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")"
+        | relation=[Relation|QualifiedName]
+        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")"
+        ":" value=LogicValue)
         ".";
 
 AssertionArgument:
@@ -174,7 +174,7 @@ ExactMultiplicity:
         exactValue=INT;
 
 IndividualDeclaration:
-        "individual" nodes+=EnumLiteral ("," nodes+=EnumLiteral)* ".";
+        "indiv" nodes+=EnumLiteral ("," nodes+=EnumLiteral)* ".";
 
 UpperBound returns ecore::EInt:
         INT | "*";
@@ -184,7 +184,7 @@ QualifiedName hidden():
 
 Identifier:
         ID | "true" | "false" | "unknown" | "error" | "class" | "abstract" | "extends" | "enum" | "pred" |
-        "individual" | "problem" | "new" | "delete" | "direct" | "rule";
+        "indiv" | "problem" | "new" | "delete" | "direct" | "rule";
 
 Integer returns ecore::EInt hidden():
         "-"? INT;
diff --git a/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java b/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
index 3c10d39e..975fdca2 100644
--- a/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
+++ b/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
@@ -53,7 +53,7 @@ public class ProblemValidator extends AbstractProblemValidator {
                 var variableOrNode = argument.getVariableOrNode();
                 if (variableOrNode instanceof Node node && !ProblemUtil.isIndividualNode(node)) {
                         var name = node.getName();
-                        var message = "Only individual nodes can be referenced in predicates. Mark '%s' as individual with the declaration 'individual %s.'"
+                        var message = "Only individual nodes can be referenced in predicates. Mark '%s' as individual with the declaration 'indiv %s.'"
                                         .formatted(name, name);
                         error(message, argument, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE,
                                         INSIGNIFICANT_INDEX, NON_INDIVIDUAL_NODE_ISSUE);
diff --git a/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend b/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend
index 9e357529..53d31a6c 100644
--- a/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend
+++ b/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend
@@ -46,7 +46,7 @@ class ProblemParsingTest {
                         error invalidTaxStatus(Person p) <->
                                 taxStatus(p, child), children(p, _q).
                         
-                        individual family.
+                        indiv family.
                         Family(family).
                         members(family, anne): true.
                         members(family, bob).
diff --git a/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend b/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend
index 5f669847..3a046341 100644
--- a/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend
+++ b/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend
@@ -81,7 +81,7 @@ class NodeScopingTest {
         def void individualNodeInAssertionTest(String qualifiedNamePrefix, boolean namedProblem) {
                 val it = parseHelper.parse('''
                         «IF namedProblem»problem test.«ENDIF»
-                        individual a, b.
+                        indiv a, b.
                         pred predicate(node x, node y) <-> node(x).
                         predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»a).
                         ?predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»b).
@@ -99,7 +99,7 @@ class NodeScopingTest {
         def void individualNodeInNodeValueAssertionTest(String qualifiedNamePrefix, boolean namedProblem) {
                 val it = parseHelper.parse('''
                         «IF namedProblem»problem test.«ENDIF»
-                        individual a.
+                        indiv a.
                         «qualifiedNamePrefix»a: 16.
                 ''')
                 assertThat(errors, empty)
@@ -112,7 +112,7 @@ class NodeScopingTest {
         def void individualNodeInPredicateTest(String qualifiedNamePrefix, boolean namedProblem) {
                 val it = parseHelper.parse('''
                         «IF namedProblem»problem test.«ENDIF»
-                        individual b.
+                        indiv b.
                         pred predicate(node a) <-> node(«qualifiedNamePrefix»b).
                 ''')
                 assertThat(errors, empty)
diff --git a/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java b/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
new file mode 100644
index 00000000..802457cb
--- /dev/null
+++ b/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
@@ -0,0 +1,215 @@
+package tools.refinery.language.tests.serializer;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import com.google.inject.Inject;
+
+import tools.refinery.language.model.ProblemUtil;
+import tools.refinery.language.model.problem.Atom;
+import tools.refinery.language.model.problem.LogicValue;
+import tools.refinery.language.model.problem.Node;
+import tools.refinery.language.model.problem.PredicateDefinition;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemFactory;
+import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.model.problem.VariableOrNode;
+import tools.refinery.language.model.tests.ProblemTestUtil;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+public class ProblemSerializerTest {
+        @Inject
+        ResourceSet resourceSet;
+
+        @Inject
+        ProblemTestUtil testUtil;
+
+        Resource resource;
+
+        Problem problem;
+
+        Problem builtin;
+
+        @BeforeEach
+        void beforeEach() {
+                problem = ProblemFactory.eINSTANCE.createProblem();
+                resource = resourceSet.createResource(URI.createFileURI("test.problem"));
+                resource.getContents().add(problem);
+                builtin = ProblemUtil.getBuiltInLibrary(problem).get();
+        }
+
+        @ParameterizedTest
+        @MethodSource
+        void assertionTest(LogicValue value, String serializedAssertion) {
+                var pred = createPred();
+                var node = ProblemFactory.eINSTANCE.createNode();
+                node.setName("a");
+                var individualDeclaration = ProblemFactory.eINSTANCE.createIndividualDeclaration();
+                individualDeclaration.getNodes().add(node);
+                problem.getStatements().add(individualDeclaration);
+                createAssertion(pred, node, value);
+
+                assertSerializedResult("pred foo ( node p ) . indiv a . " + serializedAssertion);
+        }
+
+        static Stream<Arguments> assertionTest() {
+                return Stream.of(Arguments.of(LogicValue.TRUE, "foo ( a ) ."),
+                                Arguments.of(LogicValue.FALSE, "! foo ( a ) ."),
+                                Arguments.of(LogicValue.UNKNOWN, "? foo ( a ) ."),
+                                Arguments.of(LogicValue.ERROR, "foo ( a ) : error ."));
+        }
+
+        @Test
+        void implicitNodeTest() {
+                var pred = createPred();
+                var node = ProblemFactory.eINSTANCE.createNode();
+                node.setName("a");
+                problem.getNodes().add(node);
+                createAssertion(pred, node);
+
+                assertSerializedResult("pred foo ( node p ) . foo ( a ) .");
+        }
+
+        private PredicateDefinition createPred() {
+                var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
+                pred.setName("foo");
+                var parameter = ProblemFactory.eINSTANCE.createParameter();
+                var nodeType = testUtil.findClass(builtin, "node");
+                parameter.setParameterType(nodeType);
+                parameter.setName("p");
+                pred.getParameters().add(parameter);
+                problem.getStatements().add(pred);
+                return pred;
+        }
+
+        @Test
+        void newNodeTest() {
+                var classDeclaration = ProblemFactory.eINSTANCE.createClassDeclaration();
+                classDeclaration.setName("Foo");
+                var newNode = ProblemFactory.eINSTANCE.createNode();
+                newNode.setName("new");
+                classDeclaration.setNewNode(newNode);
+                problem.getStatements().add(classDeclaration);
+                createAssertion(classDeclaration, newNode);
+
+                assertSerializedResult("class Foo . Foo ( Foo::new ) .");
+        }
+
+        private void createAssertion(Relation relation, Node node) {
+                createAssertion(relation, node, LogicValue.TRUE);
+        }
+
+        private void createAssertion(Relation relation, Node node, LogicValue value) {
+                var assertion = ProblemFactory.eINSTANCE.createAssertion();
+                assertion.setRelation(relation);
+                var argument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                argument.setNode(node);
+                assertion.getArguments().add(argument);
+                assertion.setValue(value);
+                problem.getStatements().add(assertion);
+        }
+
+        @Test
+        void implicitVariableTest() {
+                var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
+                pred.setName("foo");
+                var nodeType = testUtil.findClass(builtin, "node");
+                var parameter1 = ProblemFactory.eINSTANCE.createParameter();
+                parameter1.setParameterType(nodeType);
+                parameter1.setName("p1");
+                pred.getParameters().add(parameter1);
+                var parameter2 = ProblemFactory.eINSTANCE.createParameter();
+                parameter2.setParameterType(nodeType);
+                parameter2.setName("p2");
+                pred.getParameters().add(parameter2);
+                var conjunction = ProblemFactory.eINSTANCE.createConjunction();
+                var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
+                variable.setName("q");
+                conjunction.getImplicitVariables().add(variable);
+                var equals = testUtil.reference(nodeType, "equals");
+                conjunction.getLiterals().add(createAtom(equals, parameter1, variable));
+                conjunction.getLiterals().add(createAtom(equals, variable, parameter2));
+                pred.getBodies().add(conjunction);
+                problem.getStatements().add(pred);
+
+                assertSerializedResult("pred foo ( node p1 , node p2 ) <-> equals ( p1 , q ) , equals ( q , p2 ) .");
+        }
+
+        private Atom createAtom(Relation relation, VariableOrNode variable1, VariableOrNode variable2) {
+                var atom = ProblemFactory.eINSTANCE.createAtom();
+                atom.setRelation(relation);
+                var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                arg1.setVariableOrNode(variable1);
+                atom.getArguments().add(arg1);
+                var arg2 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                arg2.setVariableOrNode(variable2);
+                atom.getArguments().add(arg2);
+                return atom;
+        }
+
+        @Test
+        void singletonVariableTest() {
+                var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
+                pred.setName("foo");
+                var nodeType = testUtil.findClass(builtin, "node");
+                var parameter = ProblemFactory.eINSTANCE.createParameter();
+                parameter.setParameterType(nodeType);
+                parameter.setName("p");
+                pred.getParameters().add(parameter);
+                var conjunction = ProblemFactory.eINSTANCE.createConjunction();
+                var atom = ProblemFactory.eINSTANCE.createAtom();
+                var equals = testUtil.reference(nodeType, "equals");
+                atom.setRelation(equals);
+                var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                arg1.setVariableOrNode(parameter);
+                atom.getArguments().add(arg1);
+                var arg2 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
+                variable.setName("_q");
+                arg2.setSingletonVariable(variable);
+                arg2.setVariableOrNode(variable);
+                atom.getArguments().add(arg2);
+                conjunction.getLiterals().add(atom);
+                pred.getBodies().add(conjunction);
+                problem.getStatements().add(pred);
+
+                assertSerializedResult("pred foo ( node p ) <-> equals ( p , _q ) .");
+        }
+
+        private void assertSerializedResult(String expected) {
+                var outputStream = new ByteArrayOutputStream();
+                try {
+                        resource.save(outputStream, Map.of());
+                } catch (IOException e) {
+                        throw new AssertionError("Failed to serialize problem", e);
+                } finally {
+                        try {
+                                outputStream.close();
+                        } catch (IOException e) {
+                                // Nothing to handle in a test.
+                        }
+                }
+                var problemString = outputStream.toString();
+
+                assertThat(problemString, equalTo(expected));
+        }
+}