From 68e8c8ea4091482c43d810fdaa2fd6ddd6316d07 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sat, 6 Nov 2021 16:02:37 +0100 Subject: fix(lang): mark transient references Xtext fails to serialize non-transient references that have no corresponding assignment in the grammar. Therefore, we mark * Problem.nodes * ClassDeclaration.newNode * ExistentialQualifier.implicitVariables * VariableOrNodeArgument.singletonVariable as transient. This will allow serializing Problem instances using the textual concrete syntax for display. --- .../tests/serializer/ProblemSerializerTest.java | 199 +++++++++++++++++++++ 1 file changed, 199 insertions(+) create mode 100644 language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java (limited to 'language') 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..34c1d14b --- /dev/null +++ b/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java @@ -0,0 +1,199 @@ +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 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 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(); + } + + @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 ) : true ."); + } + + @Test + void individualNodeTest() { + 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); + + assertSerializedResult("pred foo ( node p ) . individual a . foo ( a ) : true ."); + } + + 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 ) : true ."); + } + + private void createAssertion(Relation relation, Node node) { + var assertion = ProblemFactory.eINSTANCE.createAssertion(); + assertion.setRelation(relation); + var argument = ProblemFactory.eINSTANCE.createNodeAssertionArgument(); + argument.setNode(node); + assertion.getArguments().add(argument); + assertion.setValue(LogicValue.TRUE); + 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)); + } +} -- cgit v1.2.3-54-g00ecf From 6b7075eccf7ddaccc797ffbdd855dd4b0bbad0d4 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sat, 6 Nov 2021 16:39:42 +0100 Subject: chore(lang): shorten keyword individual -> indiv --- .../refinery/language/mapping/tests/PartialModelMapperTest.xtend | 2 +- language-web/src/main/js/index.tsx | 2 +- language-web/src/main/js/language/problem.grammar | 2 +- language-web/src/main/js/language/problemLanguageSupport.ts | 2 +- .../language/web/ProblemWebSocketServletIntegrationTest.java | 2 +- .../language/web/xtext/servlet/TransactionExecutorTest.java | 2 +- language/src/main/java/tools/refinery/language/Problem.xtext | 4 ++-- .../java/tools/refinery/language/validation/ProblemValidator.java | 2 +- .../java/tools/refinery/language/tests/ProblemParsingTest.xtend | 2 +- .../tools/refinery/language/tests/scoping/NodeScopingTest.xtend | 6 +++--- .../refinery/language/tests/serializer/ProblemSerializerTest.java | 2 +- 11 files changed, 14 insertions(+), 14 deletions(-) (limited to 'language') diff --git a/language-to-store/src/test/java/tools/refinery/language/mapping/tests/PartialModelMapperTest.xtend b/language-to-store/src/test/java/tools/refinery/language/mapping/tests/PartialModelMapperTest.xtend index add73c87..b2fcbaa9 100644 --- a/language-to-store/src/test/java/tools/refinery/language/mapping/tests/PartialModelMapperTest.xtend +++ b/language-to-store/src/test/java/tools/refinery/language/mapping/tests/PartialModelMapperTest.xtend @@ -290,7 +290,7 @@ class PartialModelMapperTest { 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-web/src/main/js/index.tsx b/language-web/src/main/js/index.tsx index 3e077ba8..d368c9ba 100644 --- a/language-web/src/main/js/index.tsx +++ b/language-web/src/main/js/index.tsx @@ -38,7 +38,7 @@ direct rule createChild(p): children(p, q) = true, taxStatus(q, child) = true. -individual family. +indiv family. Family(family). members(family, anne). members(family, bob). diff --git a/language-web/src/main/js/language/problem.grammar b/language-web/src/main/js/language/problem.grammar index 0cbfa831..bccc2e31 100644 --- a/language-web/src/main/js/language/problem.grammar +++ b/language-web/src/main/js/language/problem.grammar @@ -35,7 +35,7 @@ statement { IndividualNodeName ":" Constant "." } | IndividualDeclaration { - ckw<"individual"> sep<",", IndividualNodeName> "." + ckw<"indiv"> sep<",", IndividualNodeName> "." } | ScopeDeclaration { kw<"scope"> sep<",", ScopeElement> "." diff --git a/language-web/src/main/js/language/problemLanguageSupport.ts b/language-web/src/main/js/language/problemLanguageSupport.ts index 1dba3447..6508a2c0 100644 --- a/language-web/src/main/js/language/problemLanguageSupport.ts +++ b/language-web/src/main/js/language/problemLanguageSupport.ts @@ -27,7 +27,7 @@ const parserWithMetadata = (parser as LRParser).configure({ styleTags({ LineComment: t.lineComment, BlockComment: t.blockComment, - 'problem class enum pred rule individual scope': t.definitionKeyword, + 'problem class enum pred rule indiv scope': t.definitionKeyword, 'abstract extends refers contains opposite error direct default': t.modifier, 'true false unknown error': t.keyword, 'new delete': t.operatorKeyword, diff --git a/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java b/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java index d34a1610..a26ce040 100644 --- a/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java +++ b/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java @@ -96,7 +96,7 @@ class ProblemWebSocketServletIntegrationTest { case 0 -> session.getRemote().sendString( "{\"id\":\"foo\",\"request\":{\"resource\":\"test.problem\",\"serviceType\":\"update\",\"fullText\":\"class Person.\n\"}}"); case 3 -> session.getRemote().sendString( - "{\"id\":\"bar\",\"request\":{\"resource\":\"test.problem\",\"serviceType\":\"update\",\"requiredStateId\":\"-80000000\",\"deltaText\":\"individual q.\nnode(q).\n\",\"deltaOffset\":\"0\",\"deltaReplaceLength\":\"0\"}}"); + "{\"id\":\"bar\",\"request\":{\"resource\":\"test.problem\",\"serviceType\":\"update\",\"requiredStateId\":\"-80000000\",\"deltaText\":\"indiv q.\nnode(q).\n\",\"deltaOffset\":\"0\",\"deltaReplaceLength\":\"0\"}}"); case 5 -> session.close(); } } diff --git a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java index 3229597e..5b8fedba 100644 --- a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java +++ b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java @@ -92,7 +92,7 @@ class TransactionExecutorTest { var stateId = updateFullText(); var responseHandler = sendRequestAndWaitForAllResponses( new XtextWebRequest("bar", Map.of("resource", RESOURCE_NAME, "serviceType", "update", "requiredStateId", - stateId, "deltaText", "individual q.\nnode(q).\n", "deltaOffset", "0", "deltaReplaceLength", "0"))); + stateId, "deltaText", "indiv q.\nnode(q).\n", "deltaOffset", "0", "deltaReplaceLength", "0"))); var captor = newCaptor(); verify(responseHandler, times(2)).onResponse(captor.capture()); diff --git a/language/src/main/java/tools/refinery/language/Problem.xtext b/language/src/main/java/tools/refinery/language/Problem.xtext index b7562759..e2723b55 100644 --- a/language/src/main/java/tools/refinery/language/Problem.xtext +++ b/language/src/main/java/tools/refinery/language/Problem.xtext @@ -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 index 34c1d14b..303da50f 100644 --- a/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java +++ b/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java @@ -74,7 +74,7 @@ public class ProblemSerializerTest { problem.getStatements().add(individualDeclaration); createAssertion(pred, node); - assertSerializedResult("pred foo ( node p ) . individual a . foo ( a ) : true ."); + assertSerializedResult("pred foo ( node p ) . indiv a . foo ( a ) : true ."); } private PredicateDefinition createPred() { -- cgit v1.2.3-54-g00ecf From 8131e670d8fc86d0f2b3035d8155d35ec6a80f9b Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sat, 6 Nov 2021 16:49:58 +0100 Subject: chore(lang): seralize assertions in short form Prefer the ! and ? operators instead of : false and : unknown and omit : true when serializing assertions. --- .../java/tools/refinery/language/Problem.xtext | 10 ++--- .../tests/serializer/ProblemSerializerTest.java | 48 ++++++++++++++-------- 2 files changed, 37 insertions(+), 21 deletions(-) (limited to 'language') diff --git a/language/src/main/java/tools/refinery/language/Problem.xtext b/language/src/main/java/tools/refinery/language/Problem.xtext index e2723b55..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: 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 index 303da50f..802457cb 100644 --- a/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java +++ b/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java @@ -6,6 +6,7 @@ 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; @@ -15,6 +16,9 @@ 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; @@ -53,28 +57,36 @@ public class ProblemSerializerTest { builtin = ProblemUtil.getBuiltInLibrary(problem).get(); } - @Test - void implicitNodeTest() { + @ParameterizedTest + @MethodSource + void assertionTest(LogicValue value, String serializedAssertion) { var pred = createPred(); var node = ProblemFactory.eINSTANCE.createNode(); node.setName("a"); - problem.getNodes().add(node); - createAssertion(pred, node); + var individualDeclaration = ProblemFactory.eINSTANCE.createIndividualDeclaration(); + individualDeclaration.getNodes().add(node); + problem.getStatements().add(individualDeclaration); + createAssertion(pred, node, value); - assertSerializedResult("pred foo ( node p ) . foo ( a ) : true ."); + assertSerializedResult("pred foo ( node p ) . indiv a . " + serializedAssertion); + } + + static Stream 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 individualNodeTest() { + void implicitNodeTest() { var pred = createPred(); var node = ProblemFactory.eINSTANCE.createNode(); node.setName("a"); - var individualDeclaration = ProblemFactory.eINSTANCE.createIndividualDeclaration(); - individualDeclaration.getNodes().add(node); - problem.getStatements().add(individualDeclaration); + problem.getNodes().add(node); createAssertion(pred, node); - assertSerializedResult("pred foo ( node p ) . indiv a . foo ( a ) : true ."); + assertSerializedResult("pred foo ( node p ) . foo ( a ) ."); } private PredicateDefinition createPred() { @@ -88,7 +100,7 @@ public class ProblemSerializerTest { problem.getStatements().add(pred); return pred; } - + @Test void newNodeTest() { var classDeclaration = ProblemFactory.eINSTANCE.createClassDeclaration(); @@ -99,16 +111,20 @@ public class ProblemSerializerTest { problem.getStatements().add(classDeclaration); createAssertion(classDeclaration, newNode); - assertSerializedResult("class Foo . Foo ( Foo::new ) : true ."); + 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(LogicValue.TRUE); + assertion.setValue(value); problem.getStatements().add(assertion); } @@ -149,7 +165,7 @@ public class ProblemSerializerTest { atom.getArguments().add(arg2); return atom; } - + @Test void singletonVariableTest() { var pred = ProblemFactory.eINSTANCE.createPredicateDefinition(); @@ -175,7 +191,7 @@ public class ProblemSerializerTest { conjunction.getLiterals().add(atom); pred.getBodies().add(conjunction); problem.getStatements().add(pred); - + assertSerializedResult("pred foo ( node p ) <-> equals ( p , _q ) ."); } -- cgit v1.2.3-54-g00ecf