From c4757c72887d0d83a51099c9f33d3e027f55a4e6 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Tue, 15 Aug 2023 12:35:06 +0200 Subject: refactor(language): invalid multiplicity trace Also simplifies attributes and flags for now, as we don't translate them to abstractions. --- .../language/tests/ProblemParsingTest.java | 3 - .../parser/antlr/TransitiveClosureParserTest.java | 4 +- .../tests/serializer/ProblemSerializerTest.java | 4 +- .../language/tests/utils/SymbolCollectorTest.java | 243 --------------------- 4 files changed, 3 insertions(+), 251 deletions(-) delete mode 100644 subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java (limited to 'subprojects/language/src/test') diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java index c7952369..96e7cf9c 100644 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java @@ -31,7 +31,6 @@ class ProblemParsingTest { class Person { Person[0..*] children opposite parent Person[0..1] parent opposite children - int age TaxStatus taxStatus } @@ -51,8 +50,6 @@ class ProblemParsingTest { children(anne, ciri). ?children(bob, ciri). taxStatus(anne, ADULT). - age(bob): 21..35. - age(ciri): 10. """); assertThat(problem.errors(), empty()); } diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java index 1180d131..ed193e90 100644 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java @@ -29,9 +29,7 @@ class TransitiveClosureParserTest { @Test void binaryAddOperatorTest() { var problem = parseHelper.parse(""" - fn int a(). - fn int b(). - pred foo() <-> a() + (b()) > 10. + pred foo(a, b) <-> a + (b) > 10. """); assertThat(problem.errors(), empty()); var literal = problem.pred("foo").conj(0).lit(0).get(); diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java index 3f3a081f..9f4f2bbf 100644 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java @@ -178,7 +178,7 @@ class ProblemSerializerTest { var variable = ProblemFactory.eINSTANCE.createImplicitVariable(); variable.setName("q"); conjunction.getImplicitVariables().add(variable); - var equals = nodeType.feature("equals"); + var equals = builtin.pred("equals").get(); conjunction.getLiterals().add(createAtom(equals, parameter1, variable)); conjunction.getLiterals().add(createAtom(equals, variable, parameter2)); pred.getBodies().add(conjunction); @@ -212,7 +212,7 @@ class ProblemSerializerTest { pred.getParameters().add(parameter); var conjunction = ProblemFactory.eINSTANCE.createConjunction(); var atom = ProblemFactory.eINSTANCE.createAtom(); - var equals = nodeType.feature("equals"); + var equals = builtin.pred("equals").get(); atom.setRelation(equals); var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeExpr(); arg1.setVariableOrNode(parameter); diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java deleted file mode 100644 index d200eeff..00000000 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java +++ /dev/null @@ -1,243 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors - * - * SPDX-License-Identifier: EPL-2.0 - */ -package tools.refinery.language.tests.utils; - -import com.google.inject.Inject; -import org.eclipse.xtext.testing.InjectWith; -import org.eclipse.xtext.testing.extensions.InjectionExtension; -import org.hamcrest.Matcher; -import org.junit.jupiter.api.Disabled; -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 tools.refinery.language.model.problem.*; -import tools.refinery.language.model.tests.utils.ProblemParseHelper; -import tools.refinery.language.tests.ProblemInjectorProvider; -import tools.refinery.language.utils.ContainmentRole; -import tools.refinery.language.utils.ProblemDesugarer; - -import java.util.stream.Stream; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.*; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; - -@ExtendWith(InjectionExtension.class) -@InjectWith(ProblemInjectorProvider.class) -class SymbolCollectorTest { - @Inject - private ProblemParseHelper parseHelper; - - @Inject - private ProblemDesugarer desugarer; - - @Test - void implicitNodeTest() { - var problem = parseHelper.parse(""" - exists(a). - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - var node = problem.node("a"); - assertThat(collectedSymbols.nodes(), hasKey(node)); - assertThat(collectedSymbols.nodes().get(node).individual(), is(false)); - } - - @Test - void individualNodeTest() { - var problem = parseHelper.parse(""" - indiv a. - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - var node = problem.individualNode("a"); - assertThat(collectedSymbols.nodes(), hasKey(node)); - assertThat(collectedSymbols.nodes().get(node).individual(), is(true)); - } - - @Test - void classTest() { - var problem = parseHelper.parse(""" - class Foo. - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - var classDeclaration = problem.findClass("Foo").get(); - assertThat(collectedSymbols.relations(), hasKey(classDeclaration)); - var classInfo = collectedSymbols.relations().get(classDeclaration); - assertThat(classInfo.parameters(), hasSize(1)); - assertThat(classInfo.containmentRole(), is(ContainmentRole.CONTAINED)); - assertThat(classInfo.hasDefinition(), is(false)); - var newNode = classDeclaration.getNewNode(); - assertThat(collectedSymbols.nodes(), hasKey(newNode)); - assertThat(collectedSymbols.nodes().get(newNode).individual(), is(false)); - assertThat(classInfo.assertions(), assertsNode(newNode, LogicValue.TRUE)); - assertThat(collectedSymbols.relations().get(problem.builtinSymbols().exists()).assertions(), - assertsNode(newNode, LogicValue.UNKNOWN)); - assertThat(collectedSymbols.relations().get(problem.builtinSymbols().equals()).assertions(), - assertsNode(newNode, LogicValue.UNKNOWN)); - } - - @Test - void abstractClassTest() { - var problem = parseHelper.parse(""" - abstract class Foo. - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - assertThat(collectedSymbols.relations().get(problem.findClass("Foo").get()).assertions(), hasSize(0)); - } - - @Test - void referenceTest() { - var problem = parseHelper.parse(""" - class Foo { - refers Foo[] bar opposite quux - refers Foo quux opposite bar - } - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - var fooClass = problem.findClass("Foo"); - var barReference = fooClass.feature("bar"); - var barInfo = collectedSymbols.relations().get(barReference); - var quuxReference = fooClass.feature("quux"); - var quuxInfo = collectedSymbols.relations().get(quuxReference); - assertThat(barInfo.containmentRole(), is(ContainmentRole.NONE)); - assertThat(barInfo.opposite(), is(quuxReference)); - assertThat(barInfo.multiplicity(), is(instanceOf(UnboundedMultiplicity.class))); - assertThat(barInfo.hasDefinition(), is(false)); - assertThat(quuxInfo.containmentRole(), is(ContainmentRole.NONE)); - assertThat(quuxInfo.opposite(), is(barReference)); - assertThat(quuxInfo.multiplicity(), is(instanceOf(ExactMultiplicity.class))); - assertThat(quuxInfo.multiplicity(), hasProperty("exactValue", is(1))); - assertThat(quuxInfo.hasDefinition(), is(false)); - } - - @Test - void containmentReferenceTest() { - var problem = parseHelper.parse(""" - class Foo { - contains Foo[] bar - } - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - assertThat(collectedSymbols.relations().get(problem.findClass("Foo").feature("bar")).containmentRole(), - is(ContainmentRole.CONTAINMENT)); - } - - @Disabled("TODO: Rework numerical references") - @Test - void dataReferenceTest() { - var problem = parseHelper.parse(""" - class Foo { - int bar - } - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - assertThat(collectedSymbols.relations().get(problem.findClass("Foo").feature("bar")).containmentRole(), - is(ContainmentRole.CONTAINMENT)); - } - - @Test - void enumTest() { - var problem = parseHelper.parse(""" - enum Foo { - bar, quux - } - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - var enumDeclaration = problem.findEnum("Foo"); - var enumInfo = collectedSymbols.relations().get(enumDeclaration.get()); - assertThat(enumInfo.containmentRole(), is(ContainmentRole.NONE)); - assertThat(enumInfo.assertions(), assertsNode(enumDeclaration.literal("bar"), LogicValue.TRUE)); - assertThat(enumInfo.assertions(), assertsNode(enumDeclaration.literal("quux"), LogicValue.TRUE)); - } - - @ParameterizedTest - @MethodSource - void predicateTest(String keyword, ContainmentRole containmentRole) { - var problem = parseHelper.parse(keyword + " foo(node x) <-> domain(x); data(x)."); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - var predicateInfo = collectedSymbols.relations().get(problem.pred("foo").get()); - assertThat(predicateInfo.containmentRole(), is(containmentRole)); - assertThat(predicateInfo.parameters(), hasSize(1)); - assertThat(predicateInfo.bodies(), hasSize(2)); - assertThat(predicateInfo.hasDefinition(), is(true)); - } - - static Stream predicateTest() { - return Stream.of(Arguments.of("pred", ContainmentRole.NONE), Arguments.of("error", ContainmentRole.NONE), - Arguments.of("contained pred", ContainmentRole.CONTAINED), Arguments.of("containment pred", - ContainmentRole.CONTAINMENT)); - } - - @ParameterizedTest - @MethodSource("logicValues") - void assertionTest(String keyword, LogicValue value) { - var problem = parseHelper.parse(""" - pred foo(node x). - foo(a): %s. - """.formatted(keyword)); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).assertions(), - assertsNode(problem.node("a"), value)); - } - - @ParameterizedTest - @MethodSource("logicValues") - void defaultAssertionTest(String keyword, LogicValue value) { - var problem = parseHelper.parse(""" - pred foo(node x). - default foo(a): %s. - """.formatted(keyword)); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).assertions(), - assertsNode(problem.node("a"), value)); - } - - static Stream logicValues() { - return Stream.of(Arguments.of("true", LogicValue.TRUE), Arguments.of("false", LogicValue.FALSE), - Arguments.of("unknown", LogicValue.UNKNOWN), Arguments.of("error", LogicValue.ERROR)); - } - - @Test - void invalidAssertionArityTest() { - var problem = parseHelper.parse(""" - pred foo(node x). - foo(a, b). - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).assertions(), hasSize(0)); - } - - @Test - void invalidProblemTest() { - var problem = parseHelper.parse(""" - class Foo { - bar[] opposite quux - Foo quux opposite bar - } - """).get(); - assertDoesNotThrow(() -> desugarer.collectSymbols(problem)); - } - - @Test - void errorAssertionTest() { - var problem = parseHelper.parse(""" - error foo(node a, node b) <-> equals(a, b). - """); - var collectedSymbols = desugarer.collectSymbols(problem.get()); - var fooInfo = collectedSymbols.relations().get(problem.pred("foo").get()); - assertThat(fooInfo.assertions(), hasSize(1)); - var assertion = fooInfo.assertions().stream().findFirst().orElseThrow(); - assertThat(assertion.getValue(), hasProperty("logicValue", is(LogicValue.FALSE))); - assertThat(assertion.getArguments(), hasSize(2)); - assertThat(assertion.getArguments(), everyItem(instanceOf(WildcardAssertionArgument.class))); - } - - private static Matcher> assertsNode(Node node, LogicValue value) { - return hasItem(allOf(hasProperty("arguments", hasItem(hasProperty("node", is(node)))), hasProperty("value", - hasProperty("logicValue", is(value))))); - } -} -- cgit v1.2.3-54-g00ecf