From 663274763e56b228efe07363b8ede4ce7bebc251 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Tue, 19 Oct 2021 03:36:26 +0200 Subject: chore: remove builtin library xtext dependency --- .../language/model/tests/ProblemTestUtil.java | 154 +++++++++++++++++++++ 1 file changed, 154 insertions(+) create mode 100644 language-model/src/testFixtures/java/tools/refinery/language/model/tests/ProblemTestUtil.java (limited to 'language-model/src/testFixtures/java/tools') diff --git a/language-model/src/testFixtures/java/tools/refinery/language/model/tests/ProblemTestUtil.java b/language-model/src/testFixtures/java/tools/refinery/language/model/tests/ProblemTestUtil.java new file mode 100644 index 00000000..b412ed1f --- /dev/null +++ b/language-model/src/testFixtures/java/tools/refinery/language/model/tests/ProblemTestUtil.java @@ -0,0 +1,154 @@ +package tools.refinery.language.model.tests; + +import java.util.List; +import java.util.stream.Stream; + +import org.eclipse.emf.ecore.resource.Resource.Diagnostic; +import org.eclipse.emf.ecore.util.EcoreUtil; + +import tools.refinery.language.model.ProblemUtil; +import tools.refinery.language.model.problem.Argument; +import tools.refinery.language.model.problem.Assertion; +import tools.refinery.language.model.problem.AssertionArgument; +import tools.refinery.language.model.problem.Atom; +import tools.refinery.language.model.problem.ClassDeclaration; +import tools.refinery.language.model.problem.Conjunction; +import tools.refinery.language.model.problem.EnumDeclaration; +import tools.refinery.language.model.problem.Literal; +import tools.refinery.language.model.problem.NamedElement; +import tools.refinery.language.model.problem.NegativeLiteral; +import tools.refinery.language.model.problem.Node; +import tools.refinery.language.model.problem.NodeAssertionArgument; +import tools.refinery.language.model.problem.NodeValueAssertion; +import tools.refinery.language.model.problem.Parameter; +import tools.refinery.language.model.problem.PredicateDefinition; +import tools.refinery.language.model.problem.Problem; +import tools.refinery.language.model.problem.ReferenceDeclaration; +import tools.refinery.language.model.problem.Relation; +import tools.refinery.language.model.problem.Statement; +import tools.refinery.language.model.problem.UniqueDeclaration; +import tools.refinery.language.model.problem.Variable; +import tools.refinery.language.model.problem.VariableOrNode; +import tools.refinery.language.model.problem.VariableOrNodeArgument; + +public class ProblemTestUtil { + public Problem builtin(Problem problem) { + return ProblemUtil.getBuiltInLibrary(problem).get(); + } + + public List errors(Problem problem) { + EcoreUtil.resolveAll(problem); + return problem.eResource().getErrors(); + } + + public List nodeNames(Problem problem) { + return problem.getNodes().stream().map(node -> node.getName()).toList(); + } + + public PredicateDefinition pred(Problem problem, String name) { + return namedStatementOfType(problem, PredicateDefinition.class, name); + } + + public Parameter param(PredicateDefinition definition, int i) { + return definition.getParameters().get(i); + } + + public Conjunction conj(PredicateDefinition definition, int i) { + return definition.getBodies().get(i); + } + + public Literal lit(Conjunction conjunction, int i) { + return conjunction.getLiterals().get(i); + } + + public Atom negated(Literal literal) { + return ((NegativeLiteral) literal).getAtom(); + } + + public Relation relation(Literal literal) { + return ((Atom) literal).getRelation(); + } + + public Argument arg(Atom atom, int i) { + return atom.getArguments().get(i); + } + + public Argument arg(Literal literal, int i) { + return arg((Atom) literal, i); + } + + public VariableOrNode variableOrNode(Argument argument) { + return ((VariableOrNodeArgument) argument).getVariableOrNode(); + } + + public Variable variable(Argument argument) { + return (Variable) variableOrNode(argument); + } + + public Node node(Argument argument) { + return (Node) variableOrNode(argument); + } + + public Assertion assertion(Problem problem, int i) { + return nthStatementOfType(problem, Assertion.class, i); + } + + public AssertionArgument arg(Assertion assertion, int i) { + return assertion.getArguments().get(i); + } + + public Node node(AssertionArgument argument) { + return ((NodeAssertionArgument) argument).getNode(); + } + + public Node node(Problem problem, String name) { + return named(problem.getNodes(), name); + } + + public Node uniqueNode(Problem problem, String name) { + var uniqueNodes = statementsOfType(problem, UniqueDeclaration.class) + .flatMap(declaration -> declaration.getNodes().stream()); + return named(uniqueNodes, name); + } + + public NodeValueAssertion nodeValueAssertion(Problem problem, int i) { + return nthStatementOfType(problem, NodeValueAssertion.class, i); + } + + public ClassDeclaration findClass(Problem problem, String name) { + return namedStatementOfType(problem, ClassDeclaration.class, name); + } + + public ReferenceDeclaration reference(ClassDeclaration declaration, String name) { + return named(declaration.getReferenceDeclarations(), name); + } + + public EnumDeclaration findEnum(Problem problem, String name) { + return namedStatementOfType(problem, EnumDeclaration.class, name); + } + + public Node literal(EnumDeclaration declaration, String name) { + return named(declaration.getLiterals(), name); + } + + private T named(Stream stream, String name) { + return stream.filter(statement -> name.equals(statement.getName())).findAny().get(); + } + + private T named(List list, String name) { + return named(list.stream(), name); + } + + private Stream statementsOfType(Problem problem, Class type) { + return problem.getStatements().stream().filter(type::isInstance).map(type::cast); + } + + private T namedStatementOfType(Problem problem, Class type, + String name) { + return named(statementsOfType(problem, type), name); + } + + private T nthStatementOfType(Problem problem, Class type, int n) { + return statementsOfType(problem, type).skip(n).findFirst().get(); + } +} -- cgit v1.2.3-70-g09d2