From 68476e86f4c04212c7aae7950550869b67442c10 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Fri, 29 Jul 2022 21:57:50 +0200 Subject: build: clean up buildSrc scripts --- buildSrc/src/main/groovy/refinery-eclipse.gradle | 1 - buildSrc/src/main/groovy/refinery-jmh.gradle | 2 +- .../tools/refinery/language/model/ProblemUtil.java | 121 -------- .../java/tools/refinery/language/ProblemUtil.java | 121 ++++++++ .../language/tests/ProblemParsingTest.xtend | 64 ---- .../language/tests/ProblemParsingTest_.xtend | 64 ++++ .../tests/rules/DirectRuleParsingTest.xtend | 96 ------ .../tests/rules/DirectRuleParsingTest_.xtend | 96 ++++++ .../language/tests/scoping/NodeScopingTest.xtend | 322 --------------------- .../language/tests/scoping/NodeScopingTest_.xtend | 322 +++++++++++++++++++++ 10 files changed, 604 insertions(+), 605 deletions(-) delete mode 100644 subprojects/language-model/src/main/java/tools/refinery/language/model/ProblemUtil.java create mode 100644 subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java delete mode 100644 subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend create mode 100644 subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest_.xtend delete mode 100644 subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.xtend create mode 100644 subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest_.xtend delete mode 100644 subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend create mode 100644 subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest_.xtend diff --git a/buildSrc/src/main/groovy/refinery-eclipse.gradle b/buildSrc/src/main/groovy/refinery-eclipse.gradle index ddd15fc2..ec8b9f6c 100644 --- a/buildSrc/src/main/groovy/refinery-eclipse.gradle +++ b/buildSrc/src/main/groovy/refinery-eclipse.gradle @@ -17,7 +17,6 @@ def eclipseResourceEncoding = tasks.register('eclipseResourceEncoding') { outputFile.withOutputStream { eclipseEncodingProperties.store(it, 'generated by ' + name) } - eclipseEncodingProperties.list(System.out) } } diff --git a/buildSrc/src/main/groovy/refinery-jmh.gradle b/buildSrc/src/main/groovy/refinery-jmh.gradle index fada4fb3..538159a4 100644 --- a/buildSrc/src/main/groovy/refinery-jmh.gradle +++ b/buildSrc/src/main/groovy/refinery-jmh.gradle @@ -25,7 +25,7 @@ dependencies { tasks.register('jmh', JavaExec) { dependsOn tasks.named('jmhClasses') - main = 'org.openjdk.jmh.Main' + mainClass = 'org.openjdk.jmh.Main' classpath = sourceSets.jmh.compileClasspath + sourceSets.jmh.runtimeClasspath } diff --git a/subprojects/language-model/src/main/java/tools/refinery/language/model/ProblemUtil.java b/subprojects/language-model/src/main/java/tools/refinery/language/model/ProblemUtil.java deleted file mode 100644 index d8958381..00000000 --- a/subprojects/language-model/src/main/java/tools/refinery/language/model/ProblemUtil.java +++ /dev/null @@ -1,121 +0,0 @@ -package tools.refinery.language.model; - -import java.util.ArrayDeque; -import java.util.Collection; -import java.util.Deque; -import java.util.HashSet; -import java.util.Optional; -import java.util.Set; - -import org.eclipse.emf.common.util.URI; -import org.eclipse.emf.ecore.EObject; -import org.eclipse.emf.ecore.resource.Resource; - -import tools.refinery.language.model.problem.ClassDeclaration; -import tools.refinery.language.model.problem.ImplicitVariable; -import tools.refinery.language.model.problem.Node; -import tools.refinery.language.model.problem.Problem; -import tools.refinery.language.model.problem.ProblemPackage; -import tools.refinery.language.model.problem.ReferenceDeclaration; -import tools.refinery.language.model.problem.Relation; -import tools.refinery.language.model.problem.Variable; - -public final class ProblemUtil { - public static final String BUILTIN_LIBRARY_NAME = "builtin"; - - public static final URI BUILTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME); - - public static final String NODE_CLASS_NAME = "node"; - - private ProblemUtil() { - throw new IllegalStateException("This is a static utility class and should not be instantiated directly"); - } - - public static boolean isSingletonVariable(Variable variable) { - return variable.eContainingFeature() == ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__SINGLETON_VARIABLE; - } - - public static boolean isImplicitVariable(Variable variable) { - return variable instanceof ImplicitVariable; - } - - public static boolean isImplicitNode(Node node) { - return node.eContainingFeature() == ProblemPackage.Literals.PROBLEM__NODES; - } - - public static boolean isImplicit(EObject eObject) { - if (eObject instanceof Node node) { - return isImplicitNode(node); - } else if (eObject instanceof Variable variable) { - return isImplicitVariable(variable); - } else { - return false; - } - } - - public static boolean isIndividualNode(Node node) { - var containingFeature = node.eContainingFeature(); - return containingFeature == ProblemPackage.Literals.INDIVIDUAL_DECLARATION__NODES - || containingFeature == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS; - } - - public static boolean isNewNode(Node node) { - return node.eContainingFeature() == ProblemPackage.Literals.CLASS_DECLARATION__NEW_NODE; - } - - public static Optional getBuiltInLibrary(EObject context) { - return Optional.ofNullable(context.eResource()).map(Resource::getResourceSet) - .map(resourceSet -> resourceSet.getResource(BUILTIN_LIBRARY_URI, true)).map(Resource::getContents) - .filter(contents -> !contents.isEmpty()).map(contents -> contents.get(0)) - .filter(Problem.class::isInstance).map(Problem.class::cast); - } - - public static boolean isBuiltIn(EObject eObject) { - if (eObject != null) { - var eResource = eObject.eResource(); - if (eResource != null) { - return BUILTIN_LIBRARY_URI.equals(eResource.getURI()); - } - } - return false; - } - - public static Optional getNodeClassDeclaration(EObject context) { - return getBuiltInLibrary(context).flatMap(problem -> problem.getStatements().stream() - .filter(ClassDeclaration.class::isInstance).map(ClassDeclaration.class::cast) - .filter(declaration -> NODE_CLASS_NAME.equals(declaration.getName())).findFirst()); - } - - public static Collection getSuperclassesAndSelf(ClassDeclaration classDeclaration) { - Set found = new HashSet<>(); - getNodeClassDeclaration(classDeclaration).ifPresent(found::add); - Deque queue = new ArrayDeque<>(); - queue.addLast(classDeclaration); - while (!queue.isEmpty()) { - ClassDeclaration current = queue.removeFirst(); - if (!found.contains(current)) { - found.add(current); - for (Relation superType : current.getSuperTypes()) { - if (superType instanceof ClassDeclaration superDeclaration) { - queue.addLast(superDeclaration); - } - } - } - } - return found; - } - - public static Collection getAllReferenceDeclarations(ClassDeclaration classDeclaration) { - Set referenceDeclarations = new HashSet<>(); - for (ClassDeclaration superclass : getSuperclassesAndSelf(classDeclaration)) { - referenceDeclarations.addAll(superclass.getReferenceDeclarations()); - } - return referenceDeclarations; - } - - private static URI getLibraryUri(String libraryName) { - return URI.createURI(ProblemUtil.class.getClassLoader() - .getResource("model/" + libraryName + "." + ProblemEMFSetup.XMI_RESOURCE_EXTENSION) - .toString()); - } -} diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java new file mode 100644 index 00000000..d8958381 --- /dev/null +++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java @@ -0,0 +1,121 @@ +package tools.refinery.language.model; + +import java.util.ArrayDeque; +import java.util.Collection; +import java.util.Deque; +import java.util.HashSet; +import java.util.Optional; +import java.util.Set; + +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; + +import tools.refinery.language.model.problem.ClassDeclaration; +import tools.refinery.language.model.problem.ImplicitVariable; +import tools.refinery.language.model.problem.Node; +import tools.refinery.language.model.problem.Problem; +import tools.refinery.language.model.problem.ProblemPackage; +import tools.refinery.language.model.problem.ReferenceDeclaration; +import tools.refinery.language.model.problem.Relation; +import tools.refinery.language.model.problem.Variable; + +public final class ProblemUtil { + public static final String BUILTIN_LIBRARY_NAME = "builtin"; + + public static final URI BUILTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME); + + public static final String NODE_CLASS_NAME = "node"; + + private ProblemUtil() { + throw new IllegalStateException("This is a static utility class and should not be instantiated directly"); + } + + public static boolean isSingletonVariable(Variable variable) { + return variable.eContainingFeature() == ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__SINGLETON_VARIABLE; + } + + public static boolean isImplicitVariable(Variable variable) { + return variable instanceof ImplicitVariable; + } + + public static boolean isImplicitNode(Node node) { + return node.eContainingFeature() == ProblemPackage.Literals.PROBLEM__NODES; + } + + public static boolean isImplicit(EObject eObject) { + if (eObject instanceof Node node) { + return isImplicitNode(node); + } else if (eObject instanceof Variable variable) { + return isImplicitVariable(variable); + } else { + return false; + } + } + + public static boolean isIndividualNode(Node node) { + var containingFeature = node.eContainingFeature(); + return containingFeature == ProblemPackage.Literals.INDIVIDUAL_DECLARATION__NODES + || containingFeature == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS; + } + + public static boolean isNewNode(Node node) { + return node.eContainingFeature() == ProblemPackage.Literals.CLASS_DECLARATION__NEW_NODE; + } + + public static Optional getBuiltInLibrary(EObject context) { + return Optional.ofNullable(context.eResource()).map(Resource::getResourceSet) + .map(resourceSet -> resourceSet.getResource(BUILTIN_LIBRARY_URI, true)).map(Resource::getContents) + .filter(contents -> !contents.isEmpty()).map(contents -> contents.get(0)) + .filter(Problem.class::isInstance).map(Problem.class::cast); + } + + public static boolean isBuiltIn(EObject eObject) { + if (eObject != null) { + var eResource = eObject.eResource(); + if (eResource != null) { + return BUILTIN_LIBRARY_URI.equals(eResource.getURI()); + } + } + return false; + } + + public static Optional getNodeClassDeclaration(EObject context) { + return getBuiltInLibrary(context).flatMap(problem -> problem.getStatements().stream() + .filter(ClassDeclaration.class::isInstance).map(ClassDeclaration.class::cast) + .filter(declaration -> NODE_CLASS_NAME.equals(declaration.getName())).findFirst()); + } + + public static Collection getSuperclassesAndSelf(ClassDeclaration classDeclaration) { + Set found = new HashSet<>(); + getNodeClassDeclaration(classDeclaration).ifPresent(found::add); + Deque queue = new ArrayDeque<>(); + queue.addLast(classDeclaration); + while (!queue.isEmpty()) { + ClassDeclaration current = queue.removeFirst(); + if (!found.contains(current)) { + found.add(current); + for (Relation superType : current.getSuperTypes()) { + if (superType instanceof ClassDeclaration superDeclaration) { + queue.addLast(superDeclaration); + } + } + } + } + return found; + } + + public static Collection getAllReferenceDeclarations(ClassDeclaration classDeclaration) { + Set referenceDeclarations = new HashSet<>(); + for (ClassDeclaration superclass : getSuperclassesAndSelf(classDeclaration)) { + referenceDeclarations.addAll(superclass.getReferenceDeclarations()); + } + return referenceDeclarations; + } + + private static URI getLibraryUri(String libraryName) { + return URI.createURI(ProblemUtil.class.getClassLoader() + .getResource("model/" + libraryName + "." + ProblemEMFSetup.XMI_RESOURCE_EXTENSION) + .toString()); + } +} diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend deleted file mode 100644 index 53d31a6c..00000000 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.xtend +++ /dev/null @@ -1,64 +0,0 @@ -/* - * generated by Xtext 2.26.0.M1 - */ -package tools.refinery.language.tests - -import com.google.inject.Inject -import org.eclipse.xtext.testing.InjectWith -import org.eclipse.xtext.testing.extensions.InjectionExtension -import org.eclipse.xtext.testing.util.ParseHelper -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.^extension.ExtendWith -import tools.refinery.language.model.problem.Problem -import tools.refinery.language.model.tests.ProblemTestUtil - -import static org.hamcrest.MatcherAssert.assertThat -import static org.hamcrest.Matchers.* - -@ExtendWith(InjectionExtension) -@InjectWith(ProblemInjectorProvider) -class ProblemParsingTest { - @Inject - ParseHelper parseHelper - - @Inject - extension ProblemTestUtil - - @Test - def void exampleTest() { - val it = parseHelper.parse(''' - class Family { - contains Person[] members - } - - class Person { - Person[0..*] children opposite parent - Person[0..1] parent opposite children - int age - TaxStatus taxStatus - } - - enum TaxStatus { - child, student, adult, retired - } - - % A child cannot have any dependents. - error invalidTaxStatus(Person p) <-> - taxStatus(p, child), children(p, _q). - - indiv family. - Family(family). - members(family, anne): true. - members(family, bob). - members(family, ciri). - children(anne, ciri). - ?children(bob, ciri). - taxStatus(anne, adult). - age(anne, 35). - bobAge: 27. - age(bob, bobAge). - !age(ciri, bobAge). - ''') - assertThat(errors, empty) - } -} diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest_.xtend b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest_.xtend new file mode 100644 index 00000000..53d31a6c --- /dev/null +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest_.xtend @@ -0,0 +1,64 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package tools.refinery.language.tests + +import com.google.inject.Inject +import org.eclipse.xtext.testing.InjectWith +import org.eclipse.xtext.testing.extensions.InjectionExtension +import org.eclipse.xtext.testing.util.ParseHelper +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.^extension.ExtendWith +import tools.refinery.language.model.problem.Problem +import tools.refinery.language.model.tests.ProblemTestUtil + +import static org.hamcrest.MatcherAssert.assertThat +import static org.hamcrest.Matchers.* + +@ExtendWith(InjectionExtension) +@InjectWith(ProblemInjectorProvider) +class ProblemParsingTest { + @Inject + ParseHelper parseHelper + + @Inject + extension ProblemTestUtil + + @Test + def void exampleTest() { + val it = parseHelper.parse(''' + class Family { + contains Person[] members + } + + class Person { + Person[0..*] children opposite parent + Person[0..1] parent opposite children + int age + TaxStatus taxStatus + } + + enum TaxStatus { + child, student, adult, retired + } + + % A child cannot have any dependents. + error invalidTaxStatus(Person p) <-> + taxStatus(p, child), children(p, _q). + + indiv family. + Family(family). + members(family, anne): true. + members(family, bob). + members(family, ciri). + children(anne, ciri). + ?children(bob, ciri). + taxStatus(anne, adult). + age(anne, 35). + bobAge: 27. + age(bob, bobAge). + !age(ciri, bobAge). + ''') + assertThat(errors, empty) + } +} diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.xtend b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.xtend deleted file mode 100644 index d60651a0..00000000 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.xtend +++ /dev/null @@ -1,96 +0,0 @@ -package tools.refinery.language.tests.rules - -import com.google.inject.Inject -import org.eclipse.xtext.testing.InjectWith -import org.eclipse.xtext.testing.extensions.InjectionExtension -import org.eclipse.xtext.testing.util.ParseHelper -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.^extension.ExtendWith -import tools.refinery.language.model.problem.Problem -import tools.refinery.language.tests.ProblemInjectorProvider -import tools.refinery.language.model.tests.ProblemTestUtil - -import static org.hamcrest.MatcherAssert.assertThat -import static org.hamcrest.Matchers.* - -@ExtendWith(InjectionExtension) -@InjectWith(ProblemInjectorProvider) -class DirectRuleParsingTest { - @Inject - ParseHelper parseHelper - - @Inject - extension ProblemTestUtil - - @Test - def void relationValueRewriteTest() { - val it = parseHelper.parse(''' - pred Person(p). - direct rule r(p1): Person(p1) = true ~> Person(p1) = false. - ''') - assertThat(errors, empty) - } - - @Test - def void relationValueMergeTest() { - val it = parseHelper.parse(''' - pred Person(p). - direct rule r(p1): Person(p1): true ~> Person(p1): false. - ''') - assertThat(errors, empty) - } - - @Test - def void newNodeTest() { - val it = parseHelper.parse(''' - pred Person(p). - direct rule r(p1): Person(p1) = true ~> new p2, Person(p2) = unknown. - ''') - assertThat(errors, empty) - assertThat(rule("r").param(0), equalTo(rule("r").conj(0).lit(0).valueAtom.arg(0).variable)) - assertThat(rule("r").actionLit(0).newVar, - equalTo(rule("r").actionLit(1).valueAtom.arg(0).variable) - ) - } - - @Test - def void differentScopeTest() { - val it = parseHelper.parse(''' - pred Friend(a, b). - direct rule r(p1): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true. - ''') - assertThat(errors, empty) - assertThat(rule("r").conj(0).lit(0).valueAtom.arg(1).variable, - not(equalTo(rule("r").actionLit(1).valueAtom.arg(1).variable))) - } - - @Test - def void parameterShadowingTest() { - val it = parseHelper.parse(''' - pred Friend(a, b). - direct rule r(p1, p2): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true. - ''') - assertThat(errors, empty) - assertThat(rule("r").param(1), - not(equalTo(rule("r").actionLit(1).valueAtom.arg(1).variable))) - } - - @Test - def void deleteParameterNodeTest() { - val it = parseHelper.parse(''' - pred Person(p). - direct rule r(p1): Person(p1): false ~> delete p1. - ''') - assertThat(errors, empty) - } - - @Test - def void deleteDifferentScopeNodeTest() { - val it = parseHelper.parse(''' - pred Friend(p). - direct rule r(p1): Friend(p1, p2) = true ~> delete p2. - ''') - assertThat(errors, not(empty)) - } - -} diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest_.xtend b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest_.xtend new file mode 100644 index 00000000..d60651a0 --- /dev/null +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest_.xtend @@ -0,0 +1,96 @@ +package tools.refinery.language.tests.rules + +import com.google.inject.Inject +import org.eclipse.xtext.testing.InjectWith +import org.eclipse.xtext.testing.extensions.InjectionExtension +import org.eclipse.xtext.testing.util.ParseHelper +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.^extension.ExtendWith +import tools.refinery.language.model.problem.Problem +import tools.refinery.language.tests.ProblemInjectorProvider +import tools.refinery.language.model.tests.ProblemTestUtil + +import static org.hamcrest.MatcherAssert.assertThat +import static org.hamcrest.Matchers.* + +@ExtendWith(InjectionExtension) +@InjectWith(ProblemInjectorProvider) +class DirectRuleParsingTest { + @Inject + ParseHelper parseHelper + + @Inject + extension ProblemTestUtil + + @Test + def void relationValueRewriteTest() { + val it = parseHelper.parse(''' + pred Person(p). + direct rule r(p1): Person(p1) = true ~> Person(p1) = false. + ''') + assertThat(errors, empty) + } + + @Test + def void relationValueMergeTest() { + val it = parseHelper.parse(''' + pred Person(p). + direct rule r(p1): Person(p1): true ~> Person(p1): false. + ''') + assertThat(errors, empty) + } + + @Test + def void newNodeTest() { + val it = parseHelper.parse(''' + pred Person(p). + direct rule r(p1): Person(p1) = true ~> new p2, Person(p2) = unknown. + ''') + assertThat(errors, empty) + assertThat(rule("r").param(0), equalTo(rule("r").conj(0).lit(0).valueAtom.arg(0).variable)) + assertThat(rule("r").actionLit(0).newVar, + equalTo(rule("r").actionLit(1).valueAtom.arg(0).variable) + ) + } + + @Test + def void differentScopeTest() { + val it = parseHelper.parse(''' + pred Friend(a, b). + direct rule r(p1): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true. + ''') + assertThat(errors, empty) + assertThat(rule("r").conj(0).lit(0).valueAtom.arg(1).variable, + not(equalTo(rule("r").actionLit(1).valueAtom.arg(1).variable))) + } + + @Test + def void parameterShadowingTest() { + val it = parseHelper.parse(''' + pred Friend(a, b). + direct rule r(p1, p2): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true. + ''') + assertThat(errors, empty) + assertThat(rule("r").param(1), + not(equalTo(rule("r").actionLit(1).valueAtom.arg(1).variable))) + } + + @Test + def void deleteParameterNodeTest() { + val it = parseHelper.parse(''' + pred Person(p). + direct rule r(p1): Person(p1): false ~> delete p1. + ''') + assertThat(errors, empty) + } + + @Test + def void deleteDifferentScopeNodeTest() { + val it = parseHelper.parse(''' + pred Friend(p). + direct rule r(p1): Friend(p1, p2) = true ~> delete p2. + ''') + assertThat(errors, not(empty)) + } + +} diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend deleted file mode 100644 index 3a046341..00000000 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.xtend +++ /dev/null @@ -1,322 +0,0 @@ -package tools.refinery.language.tests.scoping - -import com.google.inject.Inject -import java.util.stream.Stream -import org.eclipse.xtext.testing.InjectWith -import org.eclipse.xtext.testing.extensions.InjectionExtension -import org.eclipse.xtext.testing.util.ParseHelper -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 org.junit.jupiter.params.provider.ValueSource -import tools.refinery.language.model.problem.Problem -import tools.refinery.language.model.tests.ProblemTestUtil -import tools.refinery.language.tests.ProblemInjectorProvider - -import static org.hamcrest.MatcherAssert.assertThat -import static org.hamcrest.Matchers.* - -@ExtendWith(InjectionExtension) -@InjectWith(ProblemInjectorProvider) -class NodeScopingTest { - @Inject - ParseHelper parseHelper - - @Inject - extension ProblemTestUtil - - @ParameterizedTest - @ValueSource(strings=#["", "builtin::"]) - def void builtInArgumentTypeTest(String prefix) { - val it = parseHelper.parse(''' - pred predicate(«prefix»node a, «prefix»data b, «prefix»int c). - ''') - assertThat(errors, empty) - assertThat(pred('predicate').param(0).parameterType, equalTo(builtin.findClass('node'))) - assertThat(pred('predicate').param(1).parameterType, equalTo(builtin.findClass('data'))) - assertThat(pred('predicate').param(2).parameterType, equalTo(builtin.findClass('int'))) - } - - @Test - def void implicitNodeInAssertionTest() { - val it = parseHelper.parse(''' - pred predicate(node x, node y) <-> node(x). - predicate(a, a). - ?predicate(a, b). - ''') - assertThat(errors, empty) - assertThat(nodeNames, hasItems('a', 'b')) - assertThat(assertion(0).arg(0).node, equalTo(node('a'))) - assertThat(assertion(0).arg(1).node, equalTo(node('a'))) - assertThat(assertion(1).arg(0).node, equalTo(node('a'))) - assertThat(assertion(1).arg(1).node, equalTo(node('b'))) - } - - @Test - def void implicitNodeInNodeValueAssertionTest() { - val it = parseHelper.parse(''' - a: 16. - ''') - assertThat(errors, empty) - assertThat(nodeNames, hasItems('a')) - assertThat(nodeValueAssertion(0).node, equalTo(node('a'))) - } - - @Test - def void implicitNodeInPredicateTest() { - val it = parseHelper.parse(''' - pred predicate(node a) <-> node(b). - predicate(b). - ''') - assertThat(errors, empty) - assertThat(nodeNames, hasItem("b")) - assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(node("b"))) - assertThat(assertion(0).arg(0).node, equalTo(node("b"))) - } - - @ParameterizedTest - @MethodSource("individualNodeReferenceSource") - def void individualNodeInAssertionTest(String qualifiedNamePrefix, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - indiv a, b. - pred predicate(node x, node y) <-> node(x). - predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»a). - ?predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»b). - ''') - assertThat(errors, empty) - assertThat(nodeNames, empty) - assertThat(assertion(0).arg(0).node, equalTo(individualNode('a'))) - assertThat(assertion(0).arg(1).node, equalTo(individualNode('a'))) - assertThat(assertion(1).arg(0).node, equalTo(individualNode('a'))) - assertThat(assertion(1).arg(1).node, equalTo(individualNode('b'))) - } - - @ParameterizedTest - @MethodSource("individualNodeReferenceSource") - def void individualNodeInNodeValueAssertionTest(String qualifiedNamePrefix, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - indiv a. - «qualifiedNamePrefix»a: 16. - ''') - assertThat(errors, empty) - assertThat(nodeNames, empty) - assertThat(nodeValueAssertion(0).node, equalTo(individualNode('a'))) - } - - @ParameterizedTest - @MethodSource("individualNodeReferenceSource") - def void individualNodeInPredicateTest(String qualifiedNamePrefix, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - indiv b. - pred predicate(node a) <-> node(«qualifiedNamePrefix»b). - ''') - assertThat(errors, empty) - assertThat(nodeNames, empty) - assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(individualNode("b"))) - } - - static def individualNodeReferenceSource() { - Stream.of( - Arguments.of("", false), - Arguments.of("", true), - Arguments.of("test::", true) - ) - } - - @ParameterizedTest - @MethodSource("builtInNodeReferencesSource") - def void builtInNodeTest(String qualifiedName) { - val it = parseHelper.parse(''' - pred predicate(node x) <-> node(x). - predicate(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(assertion(0).arg(0).node, equalTo(builtin.findClass('int').newNode)) - } - - @ParameterizedTest - @MethodSource("builtInNodeReferencesSource") - def void builtInNodeInNodeValueAssertionTest(String qualifiedName) { - val it = parseHelper.parse(''' - «qualifiedName»: 16. - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(nodeValueAssertion(0).node, equalTo(builtin.findClass('int').newNode)) - } - - @ParameterizedTest - @MethodSource("builtInNodeReferencesSource") - def void builtInNodeInPredicateTest(String qualifiedName) { - val it = parseHelper.parse(''' - pred predicate(node x) <-> node(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findClass('int').newNode)) - } - - static def builtInNodeReferencesSource() { - Stream.of( - Arguments.of("int::new"), - Arguments.of("builtin::int::new") - ) - } - - @ParameterizedTest(name="{0}, namedProblem={1}") - @MethodSource("classNewNodeReferencesSource") - def void classNewNodeTest(String qualifiedName, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - class Foo. - pred predicate(node x) <-> node(x). - predicate(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(assertion(0).arg(0).node, equalTo(findClass('Foo').newNode)) - } - - @ParameterizedTest(name="{0}, namedProblem={1}") - @MethodSource("classNewNodeReferencesSource") - def void classNewNodeInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - class Foo. - «qualifiedName»: 16. - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(nodeValueAssertion(0).node, equalTo(findClass('Foo').newNode)) - } - - @ParameterizedTest(name="{0}, namedProblem={1}") - @MethodSource("classNewNodeReferencesSource") - def void classNewNodeInPredicateTest(String qualifiedName, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - class Foo. - pred predicate(node x) <-> node(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findClass('Foo').newNode)) - } - - static def classNewNodeReferencesSource() { - Stream.of( - Arguments.of("Foo::new", false), - Arguments.of("Foo::new", true), - Arguments.of("test::Foo::new", true) - ) - } - - @Test - def void newNodeIsNotSpecial() { - val it = parseHelper.parse(''' - class Foo. - pred predicate(node x) <-> node(x). - predicate(new). - ''') - assertThat(errors, empty) - assertThat(nodeNames, hasItem('new')) - assertThat(assertion(0).arg(0).node, not(equalTo(findClass('Foo').newNode))) - } - - @ParameterizedTest(name="{0}, namedProblem={1}") - @MethodSource("enumLiteralReferencesSource") - def void enumLiteralTest(String qualifiedName, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - enum Foo { alpha, beta } - pred predicate(Foo a) <-> node(a). - predicate(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(assertion(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha"))) - } - - @ParameterizedTest(name="{0}, namedProblem={1}") - @MethodSource("enumLiteralReferencesSource") - def void enumLiteralInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - enum Foo { alpha, beta } - «qualifiedName»: 16. - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(nodeValueAssertion(0).node, equalTo(findEnum("Foo").literal("alpha"))) - } - - @ParameterizedTest(name="{0}, namedProblem={1}") - @MethodSource("enumLiteralReferencesSource") - def void enumLiteralInPredicateTest(String qualifiedName, boolean namedProblem) { - val it = parseHelper.parse(''' - «IF namedProblem»problem test.«ENDIF» - enum Foo { alpha, beta } - pred predicate(Foo a) <-> node(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha"))) - } - - static def enumLiteralReferencesSource() { - Stream.of( - Arguments.of("alpha", false), - Arguments.of("alpha", true), - Arguments.of("Foo::alpha", false), - Arguments.of("Foo::alpha", true), - Arguments.of("test::alpha", true), - Arguments.of("test::Foo::alpha", true) - ) - } - - @ParameterizedTest - @MethodSource("builtInEnumLiteralReferencesSource") - def void builtInEnumLiteralTest(String qualifiedName) { - val it = parseHelper.parse(''' - pred predicate(node a) <-> node(a). - predicate(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(assertion(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true"))) - } - - @ParameterizedTest - @MethodSource("builtInEnumLiteralReferencesSource") - def void builtInEnumLiteralInNodeValueAssertionTest(String qualifiedName) { - val it = parseHelper.parse(''' - «qualifiedName»: 16. - ''') - assertThat(errors, empty) - assertThat(nodes, empty) - assertThat(nodeValueAssertion(0).node, equalTo(builtin.findEnum("bool").literal("true"))) - } - - @ParameterizedTest - @MethodSource("builtInEnumLiteralReferencesSource") - def void bultInEnumLiteralInPredicateTest(String qualifiedName) { - val it = parseHelper.parse(''' - pred predicate() <-> node(«qualifiedName»). - ''') - assertThat(errors, empty) - assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true"))) - } - - static def builtInEnumLiteralReferencesSource() { - Stream.of( - Arguments.of("true"), - Arguments.of("bool::true"), - Arguments.of("builtin::true"), - Arguments.of("builtin::bool::true") - ) - } -} diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest_.xtend b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest_.xtend new file mode 100644 index 00000000..3a046341 --- /dev/null +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest_.xtend @@ -0,0 +1,322 @@ +package tools.refinery.language.tests.scoping + +import com.google.inject.Inject +import java.util.stream.Stream +import org.eclipse.xtext.testing.InjectWith +import org.eclipse.xtext.testing.extensions.InjectionExtension +import org.eclipse.xtext.testing.util.ParseHelper +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 org.junit.jupiter.params.provider.ValueSource +import tools.refinery.language.model.problem.Problem +import tools.refinery.language.model.tests.ProblemTestUtil +import tools.refinery.language.tests.ProblemInjectorProvider + +import static org.hamcrest.MatcherAssert.assertThat +import static org.hamcrest.Matchers.* + +@ExtendWith(InjectionExtension) +@InjectWith(ProblemInjectorProvider) +class NodeScopingTest { + @Inject + ParseHelper parseHelper + + @Inject + extension ProblemTestUtil + + @ParameterizedTest + @ValueSource(strings=#["", "builtin::"]) + def void builtInArgumentTypeTest(String prefix) { + val it = parseHelper.parse(''' + pred predicate(«prefix»node a, «prefix»data b, «prefix»int c). + ''') + assertThat(errors, empty) + assertThat(pred('predicate').param(0).parameterType, equalTo(builtin.findClass('node'))) + assertThat(pred('predicate').param(1).parameterType, equalTo(builtin.findClass('data'))) + assertThat(pred('predicate').param(2).parameterType, equalTo(builtin.findClass('int'))) + } + + @Test + def void implicitNodeInAssertionTest() { + val it = parseHelper.parse(''' + pred predicate(node x, node y) <-> node(x). + predicate(a, a). + ?predicate(a, b). + ''') + assertThat(errors, empty) + assertThat(nodeNames, hasItems('a', 'b')) + assertThat(assertion(0).arg(0).node, equalTo(node('a'))) + assertThat(assertion(0).arg(1).node, equalTo(node('a'))) + assertThat(assertion(1).arg(0).node, equalTo(node('a'))) + assertThat(assertion(1).arg(1).node, equalTo(node('b'))) + } + + @Test + def void implicitNodeInNodeValueAssertionTest() { + val it = parseHelper.parse(''' + a: 16. + ''') + assertThat(errors, empty) + assertThat(nodeNames, hasItems('a')) + assertThat(nodeValueAssertion(0).node, equalTo(node('a'))) + } + + @Test + def void implicitNodeInPredicateTest() { + val it = parseHelper.parse(''' + pred predicate(node a) <-> node(b). + predicate(b). + ''') + assertThat(errors, empty) + assertThat(nodeNames, hasItem("b")) + assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(node("b"))) + assertThat(assertion(0).arg(0).node, equalTo(node("b"))) + } + + @ParameterizedTest + @MethodSource("individualNodeReferenceSource") + def void individualNodeInAssertionTest(String qualifiedNamePrefix, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + indiv a, b. + pred predicate(node x, node y) <-> node(x). + predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»a). + ?predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»b). + ''') + assertThat(errors, empty) + assertThat(nodeNames, empty) + assertThat(assertion(0).arg(0).node, equalTo(individualNode('a'))) + assertThat(assertion(0).arg(1).node, equalTo(individualNode('a'))) + assertThat(assertion(1).arg(0).node, equalTo(individualNode('a'))) + assertThat(assertion(1).arg(1).node, equalTo(individualNode('b'))) + } + + @ParameterizedTest + @MethodSource("individualNodeReferenceSource") + def void individualNodeInNodeValueAssertionTest(String qualifiedNamePrefix, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + indiv a. + «qualifiedNamePrefix»a: 16. + ''') + assertThat(errors, empty) + assertThat(nodeNames, empty) + assertThat(nodeValueAssertion(0).node, equalTo(individualNode('a'))) + } + + @ParameterizedTest + @MethodSource("individualNodeReferenceSource") + def void individualNodeInPredicateTest(String qualifiedNamePrefix, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + indiv b. + pred predicate(node a) <-> node(«qualifiedNamePrefix»b). + ''') + assertThat(errors, empty) + assertThat(nodeNames, empty) + assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(individualNode("b"))) + } + + static def individualNodeReferenceSource() { + Stream.of( + Arguments.of("", false), + Arguments.of("", true), + Arguments.of("test::", true) + ) + } + + @ParameterizedTest + @MethodSource("builtInNodeReferencesSource") + def void builtInNodeTest(String qualifiedName) { + val it = parseHelper.parse(''' + pred predicate(node x) <-> node(x). + predicate(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(assertion(0).arg(0).node, equalTo(builtin.findClass('int').newNode)) + } + + @ParameterizedTest + @MethodSource("builtInNodeReferencesSource") + def void builtInNodeInNodeValueAssertionTest(String qualifiedName) { + val it = parseHelper.parse(''' + «qualifiedName»: 16. + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(nodeValueAssertion(0).node, equalTo(builtin.findClass('int').newNode)) + } + + @ParameterizedTest + @MethodSource("builtInNodeReferencesSource") + def void builtInNodeInPredicateTest(String qualifiedName) { + val it = parseHelper.parse(''' + pred predicate(node x) <-> node(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findClass('int').newNode)) + } + + static def builtInNodeReferencesSource() { + Stream.of( + Arguments.of("int::new"), + Arguments.of("builtin::int::new") + ) + } + + @ParameterizedTest(name="{0}, namedProblem={1}") + @MethodSource("classNewNodeReferencesSource") + def void classNewNodeTest(String qualifiedName, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + class Foo. + pred predicate(node x) <-> node(x). + predicate(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(assertion(0).arg(0).node, equalTo(findClass('Foo').newNode)) + } + + @ParameterizedTest(name="{0}, namedProblem={1}") + @MethodSource("classNewNodeReferencesSource") + def void classNewNodeInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + class Foo. + «qualifiedName»: 16. + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(nodeValueAssertion(0).node, equalTo(findClass('Foo').newNode)) + } + + @ParameterizedTest(name="{0}, namedProblem={1}") + @MethodSource("classNewNodeReferencesSource") + def void classNewNodeInPredicateTest(String qualifiedName, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + class Foo. + pred predicate(node x) <-> node(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findClass('Foo').newNode)) + } + + static def classNewNodeReferencesSource() { + Stream.of( + Arguments.of("Foo::new", false), + Arguments.of("Foo::new", true), + Arguments.of("test::Foo::new", true) + ) + } + + @Test + def void newNodeIsNotSpecial() { + val it = parseHelper.parse(''' + class Foo. + pred predicate(node x) <-> node(x). + predicate(new). + ''') + assertThat(errors, empty) + assertThat(nodeNames, hasItem('new')) + assertThat(assertion(0).arg(0).node, not(equalTo(findClass('Foo').newNode))) + } + + @ParameterizedTest(name="{0}, namedProblem={1}") + @MethodSource("enumLiteralReferencesSource") + def void enumLiteralTest(String qualifiedName, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + enum Foo { alpha, beta } + pred predicate(Foo a) <-> node(a). + predicate(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(assertion(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha"))) + } + + @ParameterizedTest(name="{0}, namedProblem={1}") + @MethodSource("enumLiteralReferencesSource") + def void enumLiteralInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + enum Foo { alpha, beta } + «qualifiedName»: 16. + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(nodeValueAssertion(0).node, equalTo(findEnum("Foo").literal("alpha"))) + } + + @ParameterizedTest(name="{0}, namedProblem={1}") + @MethodSource("enumLiteralReferencesSource") + def void enumLiteralInPredicateTest(String qualifiedName, boolean namedProblem) { + val it = parseHelper.parse(''' + «IF namedProblem»problem test.«ENDIF» + enum Foo { alpha, beta } + pred predicate(Foo a) <-> node(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha"))) + } + + static def enumLiteralReferencesSource() { + Stream.of( + Arguments.of("alpha", false), + Arguments.of("alpha", true), + Arguments.of("Foo::alpha", false), + Arguments.of("Foo::alpha", true), + Arguments.of("test::alpha", true), + Arguments.of("test::Foo::alpha", true) + ) + } + + @ParameterizedTest + @MethodSource("builtInEnumLiteralReferencesSource") + def void builtInEnumLiteralTest(String qualifiedName) { + val it = parseHelper.parse(''' + pred predicate(node a) <-> node(a). + predicate(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(assertion(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true"))) + } + + @ParameterizedTest + @MethodSource("builtInEnumLiteralReferencesSource") + def void builtInEnumLiteralInNodeValueAssertionTest(String qualifiedName) { + val it = parseHelper.parse(''' + «qualifiedName»: 16. + ''') + assertThat(errors, empty) + assertThat(nodes, empty) + assertThat(nodeValueAssertion(0).node, equalTo(builtin.findEnum("bool").literal("true"))) + } + + @ParameterizedTest + @MethodSource("builtInEnumLiteralReferencesSource") + def void bultInEnumLiteralInPredicateTest(String qualifiedName) { + val it = parseHelper.parse(''' + pred predicate() <-> node(«qualifiedName»). + ''') + assertThat(errors, empty) + assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true"))) + } + + static def builtInEnumLiteralReferencesSource() { + Stream.of( + Arguments.of("true"), + Arguments.of("bool::true"), + Arguments.of("builtin::true"), + Arguments.of("builtin::bool::true") + ) + } +} -- cgit v1.2.3-54-g00ecf