aboutsummaryrefslogtreecommitdiffstats
path: root/subprojects/language/src/test
diff options
context:
space:
mode:
authorLibravatar Kristóf Marussy <kristof@marussy.com>2022-07-29 21:58:47 +0200
committerLibravatar Kristóf Marussy <kristof@marussy.com>2022-07-29 21:58:47 +0200
commit1d43c802f853b08f03c4b3954af242ad005c8afd (patch)
tree9a98da19c07fc587b6a3e2283aca707ad345e252 /subprojects/language/src/test
parentbuild: clean up buildSrc scripts (diff)
downloadrefinery-1d43c802f853b08f03c4b3954af242ad005c8afd.tar.gz
refinery-1d43c802f853b08f03c4b3954af242ad005c8afd.tar.zst
refinery-1d43c802f853b08f03c4b3954af242ad005c8afd.zip
refactor: simplify language project
* Move all utilities for language-model to language, since they do not make sense on their own * Convert xtend code into java
Diffstat (limited to 'subprojects/language/src/test')
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java58
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest_.xtend64
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/formatting2/ProblemFormatterTest.java2
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.java84
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest_.xtend96
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java321
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest_.xtend322
-rw-r--r--subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java31
8 files changed, 478 insertions, 500 deletions
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
new file mode 100644
index 00000000..1e8682a3
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
@@ -0,0 +1,58 @@
1package tools.refinery.language.tests;
2
3import static org.hamcrest.MatcherAssert.assertThat;
4import static org.hamcrest.Matchers.empty;
5
6import org.eclipse.xtext.testing.InjectWith;
7import org.eclipse.xtext.testing.extensions.InjectionExtension;
8import org.junit.jupiter.api.Test;
9import org.junit.jupiter.api.extension.ExtendWith;
10
11import com.google.inject.Inject;
12
13import tools.refinery.language.model.tests.utils.ProblemParseHelper;
14
15@ExtendWith(InjectionExtension.class)
16@InjectWith(ProblemInjectorProvider.class)
17class ProblemParsingTest {
18 @Inject
19 private ProblemParseHelper parseHelper;
20
21 @Test
22 void exampleTest() {
23 var problem = parseHelper.parse("""
24 class Family {
25 contains Person[] members
26 }
27
28 class Person {
29 Person[0..*] children opposite parent
30 Person[0..1] parent opposite children
31 int age
32 TaxStatus taxStatus
33 }
34
35 enum TaxStatus {
36 child, student, adult, retired
37 }
38
39 % A child cannot have any dependents.
40 error invalidTaxStatus(Person p) <->
41 taxStatus(p, child), children(p, _q).
42
43 indiv family.
44 Family(family).
45 members(family, anne): true.
46 members(family, bob).
47 members(family, ciri).
48 children(anne, ciri).
49 ?children(bob, ciri).
50 taxStatus(anne, adult).
51 age(anne, 35).
52 bobAge: 27.
53 age(bob, bobAge).
54 !age(ciri, bobAge).
55 """);
56 assertThat(problem.errors(), empty());
57 }
58}
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 @@
1/*
2 * generated by Xtext 2.26.0.M1
3 */
4package tools.refinery.language.tests
5
6import com.google.inject.Inject
7import org.eclipse.xtext.testing.InjectWith
8import org.eclipse.xtext.testing.extensions.InjectionExtension
9import org.eclipse.xtext.testing.util.ParseHelper
10import org.junit.jupiter.api.Test
11import org.junit.jupiter.api.^extension.ExtendWith
12import tools.refinery.language.model.problem.Problem
13import tools.refinery.language.model.tests.ProblemTestUtil
14
15import static org.hamcrest.MatcherAssert.assertThat
16import static org.hamcrest.Matchers.*
17
18@ExtendWith(InjectionExtension)
19@InjectWith(ProblemInjectorProvider)
20class ProblemParsingTest {
21 @Inject
22 ParseHelper<Problem> parseHelper
23
24 @Inject
25 extension ProblemTestUtil
26
27 @Test
28 def void exampleTest() {
29 val it = parseHelper.parse('''
30 class Family {
31 contains Person[] members
32 }
33
34 class Person {
35 Person[0..*] children opposite parent
36 Person[0..1] parent opposite children
37 int age
38 TaxStatus taxStatus
39 }
40
41 enum TaxStatus {
42 child, student, adult, retired
43 }
44
45 % A child cannot have any dependents.
46 error invalidTaxStatus(Person p) <->
47 taxStatus(p, child), children(p, _q).
48
49 indiv family.
50 Family(family).
51 members(family, anne): true.
52 members(family, bob).
53 members(family, ciri).
54 children(anne, ciri).
55 ?children(bob, ciri).
56 taxStatus(anne, adult).
57 age(anne, 35).
58 bobAge: 27.
59 age(bob, bobAge).
60 !age(ciri, bobAge).
61 ''')
62 assertThat(errors, empty)
63 }
64}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/formatting2/ProblemFormatterTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/formatting2/ProblemFormatterTest.java
index 41ad2d31..083c5184 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/formatting2/ProblemFormatterTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/formatting2/ProblemFormatterTest.java
@@ -230,6 +230,6 @@ class ProblemFormatterTest {
230 request.setTextRegionAccess(regionAccess); 230 request.setTextRegionAccess(regionAccess);
231 List<ITextReplacement> replacements = formatter2.format(request); 231 List<ITextReplacement> replacements = formatter2.format(request);
232 var formattedString = regionAccess.getRewriter().renderToString(replacements); 232 var formattedString = regionAccess.getRewriter().renderToString(replacements);
233 assertThat(formattedString, equalTo(expected)); 233 assertThat(formattedString.replace("\r\n", "\n"), equalTo(expected.replace("\r\n", "\n")));
234 } 234 }
235} 235}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.java
new file mode 100644
index 00000000..d5ee722b
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/DirectRuleParsingTest.java
@@ -0,0 +1,84 @@
1package tools.refinery.language.tests.rules;
2
3import static org.hamcrest.MatcherAssert.assertThat;
4import static org.hamcrest.Matchers.empty;
5import static org.hamcrest.Matchers.equalTo;
6import static org.hamcrest.Matchers.not;
7
8import org.eclipse.xtext.testing.InjectWith;
9import org.eclipse.xtext.testing.extensions.InjectionExtension;
10import org.junit.jupiter.api.Test;
11import org.junit.jupiter.api.extension.ExtendWith;
12import org.junit.jupiter.params.ParameterizedTest;
13import org.junit.jupiter.params.provider.ValueSource;
14
15import com.google.inject.Inject;
16
17import tools.refinery.language.model.tests.utils.ProblemParseHelper;
18import tools.refinery.language.tests.ProblemInjectorProvider;
19
20@ExtendWith(InjectionExtension.class)
21@InjectWith(ProblemInjectorProvider.class)
22class DirectRuleParsingTest {
23 @Inject
24 private ProblemParseHelper parseHelper;
25
26 @ParameterizedTest
27 @ValueSource(strings = { """
28 pred Person(p).
29 direct rule r(p1): Person(p1) = true ~> Person(p1) = false.
30 """, """
31 pred Person(p).
32 direct rule r(p1): Person(p1) = true ~> Person(p1): false.
33 """, """
34 pred Person(p).
35 direct rule r(p1): Person(p1): false ~> delete p1.
36 """ })
37 void simpleTest(String text) {
38 var problem = parseHelper.parse(text);
39 assertThat(problem.errors(), empty());
40 }
41
42 @Test
43 void newNodeTest() {
44 var problem = parseHelper.parse("""
45 pred Person(p).
46 direct rule r(p1): Person(p1) = true ~> new p2, Person(p2) = unknown.
47 """);
48 assertThat(problem.errors(), empty());
49 assertThat(problem.rule("r").param(0), equalTo(problem.rule("r").conj(0).lit(0).valueAtom().arg(0).variable()));
50 assertThat(problem.rule("r").actionLit(0).newVar(),
51 equalTo(problem.rule("r").actionLit(1).valueAtom().arg(0).variable()));
52 }
53
54 @Test
55 void differentScopeTest() {
56 var problem = parseHelper.parse("""
57 pred Friend(a, b).
58 direct rule r(p1): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true.
59 """);
60 assertThat(problem.errors(), empty());
61 assertThat(problem.rule("r").conj(0).lit(0).valueAtom().arg(1).variable(),
62 not(equalTo(problem.rule("r").actionLit(1).valueAtom().arg(1).variable())));
63 }
64
65 @Test
66 void parameterShadowingTest() {
67 var problem = parseHelper.parse("""
68 pred Friend(a, b).
69 direct rule r(p1, p2): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true.
70 """);
71 assertThat(problem.errors(), empty());
72 assertThat(problem.rule("r").param(1),
73 not(equalTo(problem.rule("r").actionLit(1).valueAtom().arg(1).variable())));
74 }
75
76 @Test
77 void deleteDifferentScopeNodeTest() {
78 var problem = parseHelper.parse("""
79 pred Person(p).
80 direct rule r(p1): Friend(p1, p2) = true ~> delete p2.
81 """);
82 assertThat(problem.errors(), not(empty()));
83 }
84}
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 @@
1package tools.refinery.language.tests.rules
2
3import com.google.inject.Inject
4import org.eclipse.xtext.testing.InjectWith
5import org.eclipse.xtext.testing.extensions.InjectionExtension
6import org.eclipse.xtext.testing.util.ParseHelper
7import org.junit.jupiter.api.Test
8import org.junit.jupiter.api.^extension.ExtendWith
9import tools.refinery.language.model.problem.Problem
10import tools.refinery.language.tests.ProblemInjectorProvider
11import tools.refinery.language.model.tests.ProblemTestUtil
12
13import static org.hamcrest.MatcherAssert.assertThat
14import static org.hamcrest.Matchers.*
15
16@ExtendWith(InjectionExtension)
17@InjectWith(ProblemInjectorProvider)
18class DirectRuleParsingTest {
19 @Inject
20 ParseHelper<Problem> parseHelper
21
22 @Inject
23 extension ProblemTestUtil
24
25 @Test
26 def void relationValueRewriteTest() {
27 val it = parseHelper.parse('''
28 pred Person(p).
29 direct rule r(p1): Person(p1) = true ~> Person(p1) = false.
30 ''')
31 assertThat(errors, empty)
32 }
33
34 @Test
35 def void relationValueMergeTest() {
36 val it = parseHelper.parse('''
37 pred Person(p).
38 direct rule r(p1): Person(p1): true ~> Person(p1): false.
39 ''')
40 assertThat(errors, empty)
41 }
42
43 @Test
44 def void newNodeTest() {
45 val it = parseHelper.parse('''
46 pred Person(p).
47 direct rule r(p1): Person(p1) = true ~> new p2, Person(p2) = unknown.
48 ''')
49 assertThat(errors, empty)
50 assertThat(rule("r").param(0), equalTo(rule("r").conj(0).lit(0).valueAtom.arg(0).variable))
51 assertThat(rule("r").actionLit(0).newVar,
52 equalTo(rule("r").actionLit(1).valueAtom.arg(0).variable)
53 )
54 }
55
56 @Test
57 def void differentScopeTest() {
58 val it = parseHelper.parse('''
59 pred Friend(a, b).
60 direct rule r(p1): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true.
61 ''')
62 assertThat(errors, empty)
63 assertThat(rule("r").conj(0).lit(0).valueAtom.arg(1).variable,
64 not(equalTo(rule("r").actionLit(1).valueAtom.arg(1).variable)))
65 }
66
67 @Test
68 def void parameterShadowingTest() {
69 val it = parseHelper.parse('''
70 pred Friend(a, b).
71 direct rule r(p1, p2): Friend(p1, p2) = false ~> new p2, Friend(p1, p2) = true.
72 ''')
73 assertThat(errors, empty)
74 assertThat(rule("r").param(1),
75 not(equalTo(rule("r").actionLit(1).valueAtom.arg(1).variable)))
76 }
77
78 @Test
79 def void deleteParameterNodeTest() {
80 val it = parseHelper.parse('''
81 pred Person(p).
82 direct rule r(p1): Person(p1): false ~> delete p1.
83 ''')
84 assertThat(errors, empty)
85 }
86
87 @Test
88 def void deleteDifferentScopeNodeTest() {
89 val it = parseHelper.parse('''
90 pred Friend(p).
91 direct rule r(p1): Friend(p1, p2) = true ~> delete p2.
92 ''')
93 assertThat(errors, not(empty))
94 }
95
96}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
new file mode 100644
index 00000000..5c905ede
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
@@ -0,0 +1,321 @@
1package tools.refinery.language.tests.scoping;
2
3import static org.hamcrest.MatcherAssert.assertThat;
4import static org.hamcrest.Matchers.empty;
5import static org.hamcrest.Matchers.equalTo;
6import static org.hamcrest.Matchers.hasItems;
7import static org.hamcrest.Matchers.not;
8
9import java.util.stream.Stream;
10
11import org.eclipse.xtext.testing.InjectWith;
12import org.eclipse.xtext.testing.extensions.InjectionExtension;
13import org.junit.jupiter.api.Test;
14import org.junit.jupiter.api.extension.ExtendWith;
15import org.junit.jupiter.params.ParameterizedTest;
16import org.junit.jupiter.params.provider.Arguments;
17import org.junit.jupiter.params.provider.MethodSource;
18import org.junit.jupiter.params.provider.ValueSource;
19
20import com.google.inject.Inject;
21
22import tools.refinery.language.model.tests.utils.ProblemParseHelper;
23import tools.refinery.language.model.tests.utils.WrappedProblem;
24import tools.refinery.language.tests.ProblemInjectorProvider;
25
26@ExtendWith(InjectionExtension.class)
27@InjectWith(ProblemInjectorProvider.class)
28class NodeScopingTest {
29 @Inject
30 private ProblemParseHelper parseHelper;
31
32 @ParameterizedTest
33 @ValueSource(strings = { "", "builtin::" })
34 void builtInArgumentTypeTest(String qualifiedNamePrefix) {
35 var problem = parse("""
36 pred predicate({PARAM}node a, {PARAM}data b, {PARAM}int c).
37 """, qualifiedNamePrefix);
38 assertThat(problem.errors(), empty());
39 assertThat(problem.pred("predicate").param(0).getParameterType(),
40 equalTo(problem.builtin().findClass("node").get()));
41 assertThat(problem.pred("predicate").param(1).getParameterType(),
42 equalTo(problem.builtin().findClass("data").get()));
43 assertThat(problem.pred("predicate").param(2).getParameterType(),
44 equalTo(problem.builtin().findClass("int").get()));
45 }
46
47 @Test
48 void implicitNodeInAssertionTest() {
49 var problem = parse("""
50 pred predicate(node x, node y) <-> node(x).
51 predicate(a, a).
52 ?predicate(a, b).
53 """);
54 assertThat(problem.errors(), empty());
55 assertThat(problem.nodeNames(), hasItems("a", "b"));
56 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("a")));
57 assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.node("a")));
58 assertThat(problem.assertion(1).arg(0).node(), equalTo(problem.node("a")));
59 assertThat(problem.assertion(1).arg(1).node(), equalTo(problem.node("b")));
60 }
61
62 @Test
63 void implicitNodeInNodeValueAssertionTest() {
64 var problem = parseHelper.parse("""
65 a: 16.
66 """);
67 assertThat(problem.errors(), empty());
68 assertThat(problem.nodeNames(), hasItems("a"));
69 assertThat(problem.nodeValueAssertion(0).getNode(), equalTo(problem.node("a")));
70 }
71
72 @Test
73 void implicitNodeInPredicateTest() {
74 var problem = parse("""
75 pred predicate(node a) <-> node(b).
76 predicate(b).
77 """);
78 assertThat(problem.errors(), empty());
79 assertThat(problem.nodeNames(), hasItems("b"));
80 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.node("b")));
81 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("b")));
82 }
83
84 @ParameterizedTest
85 @MethodSource("individualNodeReferenceSource")
86 void individualNodeInAssertionTest(String qualifiedNamePrefix, boolean namedProblem) {
87 var problem = parse("""
88 indiv a, b.
89 pred predicate(node x, node y) <-> node(x).
90 predicate({PARAM}a, {PARAM}a).
91 ?predicate({PARAM}a, {PARAM}b).
92 """, qualifiedNamePrefix, namedProblem);
93 assertThat(problem.errors(), empty());
94 assertThat(problem.nodeNames(), empty());
95 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.individualNode("a")));
96 assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.individualNode("a")));
97 assertThat(problem.assertion(1).arg(0).node(), equalTo(problem.individualNode("a")));
98 assertThat(problem.assertion(1).arg(1).node(), equalTo(problem.individualNode("b")));
99 }
100
101 @ParameterizedTest
102 @MethodSource("individualNodeReferenceSource")
103 void individualNodeInNodeValueAssertionTest(String qualifiedNamePrefix, boolean namedProblem) {
104 var problem = parse("""
105 indiv a.
106 {PARAM}a: 16.
107 """, qualifiedNamePrefix, namedProblem);
108 assertThat(problem.errors(), empty());
109 assertThat(problem.nodeNames(), empty());
110 assertThat(problem.nodeValueAssertion(0).getNode(), equalTo(problem.individualNode("a")));
111 }
112
113 @ParameterizedTest
114 @MethodSource("individualNodeReferenceSource")
115 void individualNodeInPredicateTest(String qualifiedNamePrefix, boolean namedProblem) {
116 var problem = parse("""
117 indiv b.
118 pred predicate(node a) <-> node({PARAM}b).
119 """);
120 assertThat(problem.errors(), empty());
121 assertThat(problem.nodeNames(), empty());
122 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.individualNode("b")));
123 }
124
125 static Stream<Arguments> individualNodeReferenceSource() {
126 return Stream.of(Arguments.of("", false), Arguments.of("", true), Arguments.of("test::", true));
127 }
128
129 @ParameterizedTest
130 @MethodSource("builtInNodeReferencesSource")
131 void builtInNodeTest(String qualifiedName) {
132 var problem = parse("""
133 pred predicate(node x) <-> node(x).
134 predicate({PARAM}).
135 """, qualifiedName);
136 assertThat(problem.errors(), empty());
137 assertThat(problem.nodeNames(), empty());
138 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.builtin().findClass("int").get().getNewNode()));
139 }
140
141 @ParameterizedTest
142 @MethodSource("builtInNodeReferencesSource")
143 void builtInNodeInNodeValueAssertionTest(String qualifiedName) {
144 var problem = parse("""
145 {PARAM}: 16.
146 """, qualifiedName);
147 assertThat(problem.errors(), empty());
148 assertThat(problem.nodeNames(), empty());
149 assertThat(problem.nodeValueAssertion(0).getNode(),
150 equalTo(problem.builtin().findClass("int").get().getNewNode()));
151 }
152
153 @ParameterizedTest
154 @MethodSource("builtInNodeReferencesSource")
155 void builtInNodeInPredicateTest(String qualifiedName) {
156 var problem = parse("""
157 pred predicate(node x) <-> node({PARAM}).
158 """, qualifiedName);
159 assertThat(problem.errors(), empty());
160 assertThat(problem.nodeNames(), empty());
161 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
162 equalTo(problem.builtin().findClass("int").get().getNewNode()));
163 }
164
165 static Stream<Arguments> builtInNodeReferencesSource() {
166 return Stream.of(Arguments.of("int::new"), Arguments.of("builtin::int::new"));
167 }
168
169 @ParameterizedTest
170 @MethodSource("classNewNodeReferencesSource")
171 void classNewNodeTest(String qualifiedName, boolean namedProblem) {
172 var problem = parse("""
173 class Foo.
174 pred predicate(node x) <-> node(x).
175 predicate({PARAM}).
176 """, qualifiedName, namedProblem);
177 assertThat(problem.errors(), empty());
178 assertThat(problem.nodeNames(), empty());
179 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findClass("Foo").get().getNewNode()));
180 }
181
182 @ParameterizedTest
183 @MethodSource("classNewNodeReferencesSource")
184 void classNewNodeInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) {
185 var problem = parse("""
186 class Foo.
187 {PARAM}: 16.
188 """, qualifiedName, namedProblem);
189 assertThat(problem.errors(), empty());
190 assertThat(problem.nodeNames(), empty());
191 assertThat(problem.nodeValueAssertion(0).getNode(), equalTo(problem.findClass("Foo").get().getNewNode()));
192 }
193
194 @ParameterizedTest
195 @MethodSource("classNewNodeReferencesSource")
196 void classNewNodeInPredicateTest(String qualifiedName, boolean namedProblem) {
197 var problem = parse("""
198 class Foo.
199 pred predicate(node x) <-> node({PARAM}).
200 """, qualifiedName, namedProblem);
201 assertThat(problem.errors(), empty());
202 assertThat(problem.nodeNames(), empty());
203 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
204 equalTo(problem.findClass("Foo").get().getNewNode()));
205 }
206
207 static Stream<Arguments> classNewNodeReferencesSource() {
208 return Stream.of(Arguments.of("Foo::new", false), Arguments.of("Foo::new", true),
209 Arguments.of("test::Foo::new", true));
210 }
211
212 @Test
213 void newNodeIsNotSpecial() {
214 var problem = parse("""
215 class Foo.
216 pred predicate(node x) <-> node(x).
217 predicate(new).
218 """);
219 assertThat(problem.errors(), empty());
220 assertThat(problem.nodeNames(), hasItems("new"));
221 assertThat(problem.assertion(0).arg(0).node(), not(equalTo(problem.findClass("Foo").get().getNewNode())));
222 }
223
224 @ParameterizedTest
225 @MethodSource("enumLiteralReferencesSource")
226 void enumLiteralTest(String qualifiedName, boolean namedProblem) {
227 var problem = parse("""
228 enum Foo { alpha, beta }
229 pred predicate(Foo a) <-> node(a).
230 predicate({PARAM}).
231 """, qualifiedName, namedProblem);
232 assertThat(problem.errors(), empty());
233 assertThat(problem.nodeNames(), empty());
234 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findEnum("Foo").literal("alpha")));
235 }
236
237 @ParameterizedTest
238 @MethodSource("enumLiteralReferencesSource")
239 void enumLiteralInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) {
240 var problem = parse("""
241 enum Foo { alpha, beta }
242 {PARAM}: 16.
243 """, qualifiedName, namedProblem);
244 assertThat(problem.errors(), empty());
245 assertThat(problem.nodeNames(), empty());
246 assertThat(problem.nodeValueAssertion(0).getNode(), equalTo(problem.findEnum("Foo").literal("alpha")));
247 }
248
249 @ParameterizedTest
250 @MethodSource("enumLiteralReferencesSource")
251 void enumLiteralInPredicateTest(String qualifiedName, boolean namedProblem) {
252 var problem = parse("""
253 enum Foo { alpha, beta }
254 pred predicate(Foo a) <-> node({PARAM}).
255 """, qualifiedName, namedProblem);
256 assertThat(problem.errors(), empty());
257 assertThat(problem.nodeNames(), empty());
258 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
259 equalTo(problem.findEnum("Foo").literal("alpha")));
260 }
261
262 static Stream<Arguments> enumLiteralReferencesSource() {
263 return Stream.of(Arguments.of("alpha", false), Arguments.of("alpha", true), Arguments.of("Foo::alpha", false),
264 Arguments.of("Foo::alpha", true), Arguments.of("test::alpha", true),
265 Arguments.of("test::Foo::alpha", true));
266 }
267
268 @ParameterizedTest
269 @MethodSource("builtInEnumLiteralReferencesSource")
270 void builtInEnumLiteralTest(String qualifiedName) {
271 var problem = parse("""
272 pred predicate(node a) <-> node(a).
273 predicate({PARAM}).
274 """, qualifiedName);
275 assertThat(problem.errors(), empty());
276 assertThat(problem.nodeNames(), empty());
277 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.builtin().findEnum("bool").literal("true")));
278 }
279
280 @ParameterizedTest
281 @MethodSource("builtInEnumLiteralReferencesSource")
282 void builtInEnumLiteralInNodeValueAssertionTest(String qualifiedName) {
283 var problem = parse("""
284 {PARAM}: 16.
285 """, qualifiedName);
286 assertThat(problem.errors(), empty());
287 assertThat(problem.nodeNames(), empty());
288 assertThat(problem.nodeValueAssertion(0).getNode(),
289 equalTo(problem.builtin().findEnum("bool").literal("true")));
290 }
291
292 @ParameterizedTest
293 @MethodSource("builtInEnumLiteralReferencesSource")
294 void bultInEnumLiteralInPredicateTest(String qualifiedName) {
295 var problem = parse("""
296 pred predicate() <-> node({PARAM}).
297 """, qualifiedName);
298 assertThat(problem.errors(), empty());
299 assertThat(problem.nodeNames(), empty());
300 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
301 equalTo(problem.builtin().findEnum("bool").literal("true")));
302 }
303
304 static Stream<Arguments> builtInEnumLiteralReferencesSource() {
305 return Stream.of(Arguments.of("true"), Arguments.of("bool::true"), Arguments.of("builtin::true"),
306 Arguments.of("builtin::bool::true"));
307 }
308
309 private WrappedProblem parse(String text, String parameter, boolean namedProblem) {
310 var problemName = namedProblem ? "problem test.\n" : "";
311 return parseHelper.parse(problemName + text.replace("{PARAM}", parameter));
312 }
313
314 private WrappedProblem parse(String text, String parameter) {
315 return parse(text, parameter, false);
316 }
317
318 private WrappedProblem parse(String text) {
319 return parse(text, "");
320 }
321}
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 @@
1package tools.refinery.language.tests.scoping
2
3import com.google.inject.Inject
4import java.util.stream.Stream
5import org.eclipse.xtext.testing.InjectWith
6import org.eclipse.xtext.testing.extensions.InjectionExtension
7import org.eclipse.xtext.testing.util.ParseHelper
8import org.junit.jupiter.api.Test
9import org.junit.jupiter.api.^extension.ExtendWith
10import org.junit.jupiter.params.ParameterizedTest
11import org.junit.jupiter.params.provider.Arguments
12import org.junit.jupiter.params.provider.MethodSource
13import org.junit.jupiter.params.provider.ValueSource
14import tools.refinery.language.model.problem.Problem
15import tools.refinery.language.model.tests.ProblemTestUtil
16import tools.refinery.language.tests.ProblemInjectorProvider
17
18import static org.hamcrest.MatcherAssert.assertThat
19import static org.hamcrest.Matchers.*
20
21@ExtendWith(InjectionExtension)
22@InjectWith(ProblemInjectorProvider)
23class NodeScopingTest {
24 @Inject
25 ParseHelper<Problem> parseHelper
26
27 @Inject
28 extension ProblemTestUtil
29
30 @ParameterizedTest
31 @ValueSource(strings=#["", "builtin::"])
32 def void builtInArgumentTypeTest(String prefix) {
33 val it = parseHelper.parse('''
34 pred predicate(«prefix»node a, «prefix»data b, «prefix»int c).
35 ''')
36 assertThat(errors, empty)
37 assertThat(pred('predicate').param(0).parameterType, equalTo(builtin.findClass('node')))
38 assertThat(pred('predicate').param(1).parameterType, equalTo(builtin.findClass('data')))
39 assertThat(pred('predicate').param(2).parameterType, equalTo(builtin.findClass('int')))
40 }
41
42 @Test
43 def void implicitNodeInAssertionTest() {
44 val it = parseHelper.parse('''
45 pred predicate(node x, node y) <-> node(x).
46 predicate(a, a).
47 ?predicate(a, b).
48 ''')
49 assertThat(errors, empty)
50 assertThat(nodeNames, hasItems('a', 'b'))
51 assertThat(assertion(0).arg(0).node, equalTo(node('a')))
52 assertThat(assertion(0).arg(1).node, equalTo(node('a')))
53 assertThat(assertion(1).arg(0).node, equalTo(node('a')))
54 assertThat(assertion(1).arg(1).node, equalTo(node('b')))
55 }
56
57 @Test
58 def void implicitNodeInNodeValueAssertionTest() {
59 val it = parseHelper.parse('''
60 a: 16.
61 ''')
62 assertThat(errors, empty)
63 assertThat(nodeNames, hasItems('a'))
64 assertThat(nodeValueAssertion(0).node, equalTo(node('a')))
65 }
66
67 @Test
68 def void implicitNodeInPredicateTest() {
69 val it = parseHelper.parse('''
70 pred predicate(node a) <-> node(b).
71 predicate(b).
72 ''')
73 assertThat(errors, empty)
74 assertThat(nodeNames, hasItem("b"))
75 assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(node("b")))
76 assertThat(assertion(0).arg(0).node, equalTo(node("b")))
77 }
78
79 @ParameterizedTest
80 @MethodSource("individualNodeReferenceSource")
81 def void individualNodeInAssertionTest(String qualifiedNamePrefix, boolean namedProblem) {
82 val it = parseHelper.parse('''
83 «IF namedProblem»problem test.«ENDIF»
84 indiv a, b.
85 pred predicate(node x, node y) <-> node(x).
86 predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»a).
87 ?predicate(«qualifiedNamePrefix»a, «qualifiedNamePrefix»b).
88 ''')
89 assertThat(errors, empty)
90 assertThat(nodeNames, empty)
91 assertThat(assertion(0).arg(0).node, equalTo(individualNode('a')))
92 assertThat(assertion(0).arg(1).node, equalTo(individualNode('a')))
93 assertThat(assertion(1).arg(0).node, equalTo(individualNode('a')))
94 assertThat(assertion(1).arg(1).node, equalTo(individualNode('b')))
95 }
96
97 @ParameterizedTest
98 @MethodSource("individualNodeReferenceSource")
99 def void individualNodeInNodeValueAssertionTest(String qualifiedNamePrefix, boolean namedProblem) {
100 val it = parseHelper.parse('''
101 «IF namedProblem»problem test.«ENDIF»
102 indiv a.
103 «qualifiedNamePrefix»a: 16.
104 ''')
105 assertThat(errors, empty)
106 assertThat(nodeNames, empty)
107 assertThat(nodeValueAssertion(0).node, equalTo(individualNode('a')))
108 }
109
110 @ParameterizedTest
111 @MethodSource("individualNodeReferenceSource")
112 def void individualNodeInPredicateTest(String qualifiedNamePrefix, boolean namedProblem) {
113 val it = parseHelper.parse('''
114 «IF namedProblem»problem test.«ENDIF»
115 indiv b.
116 pred predicate(node a) <-> node(«qualifiedNamePrefix»b).
117 ''')
118 assertThat(errors, empty)
119 assertThat(nodeNames, empty)
120 assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(individualNode("b")))
121 }
122
123 static def individualNodeReferenceSource() {
124 Stream.of(
125 Arguments.of("", false),
126 Arguments.of("", true),
127 Arguments.of("test::", true)
128 )
129 }
130
131 @ParameterizedTest
132 @MethodSource("builtInNodeReferencesSource")
133 def void builtInNodeTest(String qualifiedName) {
134 val it = parseHelper.parse('''
135 pred predicate(node x) <-> node(x).
136 predicate(«qualifiedName»).
137 ''')
138 assertThat(errors, empty)
139 assertThat(nodes, empty)
140 assertThat(assertion(0).arg(0).node, equalTo(builtin.findClass('int').newNode))
141 }
142
143 @ParameterizedTest
144 @MethodSource("builtInNodeReferencesSource")
145 def void builtInNodeInNodeValueAssertionTest(String qualifiedName) {
146 val it = parseHelper.parse('''
147 «qualifiedName»: 16.
148 ''')
149 assertThat(errors, empty)
150 assertThat(nodes, empty)
151 assertThat(nodeValueAssertion(0).node, equalTo(builtin.findClass('int').newNode))
152 }
153
154 @ParameterizedTest
155 @MethodSource("builtInNodeReferencesSource")
156 def void builtInNodeInPredicateTest(String qualifiedName) {
157 val it = parseHelper.parse('''
158 pred predicate(node x) <-> node(«qualifiedName»).
159 ''')
160 assertThat(errors, empty)
161 assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findClass('int').newNode))
162 }
163
164 static def builtInNodeReferencesSource() {
165 Stream.of(
166 Arguments.of("int::new"),
167 Arguments.of("builtin::int::new")
168 )
169 }
170
171 @ParameterizedTest(name="{0}, namedProblem={1}")
172 @MethodSource("classNewNodeReferencesSource")
173 def void classNewNodeTest(String qualifiedName, boolean namedProblem) {
174 val it = parseHelper.parse('''
175 «IF namedProblem»problem test.«ENDIF»
176 class Foo.
177 pred predicate(node x) <-> node(x).
178 predicate(«qualifiedName»).
179 ''')
180 assertThat(errors, empty)
181 assertThat(nodes, empty)
182 assertThat(assertion(0).arg(0).node, equalTo(findClass('Foo').newNode))
183 }
184
185 @ParameterizedTest(name="{0}, namedProblem={1}")
186 @MethodSource("classNewNodeReferencesSource")
187 def void classNewNodeInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) {
188 val it = parseHelper.parse('''
189 «IF namedProblem»problem test.«ENDIF»
190 class Foo.
191 «qualifiedName»: 16.
192 ''')
193 assertThat(errors, empty)
194 assertThat(nodes, empty)
195 assertThat(nodeValueAssertion(0).node, equalTo(findClass('Foo').newNode))
196 }
197
198 @ParameterizedTest(name="{0}, namedProblem={1}")
199 @MethodSource("classNewNodeReferencesSource")
200 def void classNewNodeInPredicateTest(String qualifiedName, boolean namedProblem) {
201 val it = parseHelper.parse('''
202 «IF namedProblem»problem test.«ENDIF»
203 class Foo.
204 pred predicate(node x) <-> node(«qualifiedName»).
205 ''')
206 assertThat(errors, empty)
207 assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findClass('Foo').newNode))
208 }
209
210 static def classNewNodeReferencesSource() {
211 Stream.of(
212 Arguments.of("Foo::new", false),
213 Arguments.of("Foo::new", true),
214 Arguments.of("test::Foo::new", true)
215 )
216 }
217
218 @Test
219 def void newNodeIsNotSpecial() {
220 val it = parseHelper.parse('''
221 class Foo.
222 pred predicate(node x) <-> node(x).
223 predicate(new).
224 ''')
225 assertThat(errors, empty)
226 assertThat(nodeNames, hasItem('new'))
227 assertThat(assertion(0).arg(0).node, not(equalTo(findClass('Foo').newNode)))
228 }
229
230 @ParameterizedTest(name="{0}, namedProblem={1}")
231 @MethodSource("enumLiteralReferencesSource")
232 def void enumLiteralTest(String qualifiedName, boolean namedProblem) {
233 val it = parseHelper.parse('''
234 «IF namedProblem»problem test.«ENDIF»
235 enum Foo { alpha, beta }
236 pred predicate(Foo a) <-> node(a).
237 predicate(«qualifiedName»).
238 ''')
239 assertThat(errors, empty)
240 assertThat(nodes, empty)
241 assertThat(assertion(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha")))
242 }
243
244 @ParameterizedTest(name="{0}, namedProblem={1}")
245 @MethodSource("enumLiteralReferencesSource")
246 def void enumLiteralInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) {
247 val it = parseHelper.parse('''
248 «IF namedProblem»problem test.«ENDIF»
249 enum Foo { alpha, beta }
250 «qualifiedName»: 16.
251 ''')
252 assertThat(errors, empty)
253 assertThat(nodes, empty)
254 assertThat(nodeValueAssertion(0).node, equalTo(findEnum("Foo").literal("alpha")))
255 }
256
257 @ParameterizedTest(name="{0}, namedProblem={1}")
258 @MethodSource("enumLiteralReferencesSource")
259 def void enumLiteralInPredicateTest(String qualifiedName, boolean namedProblem) {
260 val it = parseHelper.parse('''
261 «IF namedProblem»problem test.«ENDIF»
262 enum Foo { alpha, beta }
263 pred predicate(Foo a) <-> node(«qualifiedName»).
264 ''')
265 assertThat(errors, empty)
266 assertThat(nodes, empty)
267 assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha")))
268 }
269
270 static def enumLiteralReferencesSource() {
271 Stream.of(
272 Arguments.of("alpha", false),
273 Arguments.of("alpha", true),
274 Arguments.of("Foo::alpha", false),
275 Arguments.of("Foo::alpha", true),
276 Arguments.of("test::alpha", true),
277 Arguments.of("test::Foo::alpha", true)
278 )
279 }
280
281 @ParameterizedTest
282 @MethodSource("builtInEnumLiteralReferencesSource")
283 def void builtInEnumLiteralTest(String qualifiedName) {
284 val it = parseHelper.parse('''
285 pred predicate(node a) <-> node(a).
286 predicate(«qualifiedName»).
287 ''')
288 assertThat(errors, empty)
289 assertThat(nodes, empty)
290 assertThat(assertion(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true")))
291 }
292
293 @ParameterizedTest
294 @MethodSource("builtInEnumLiteralReferencesSource")
295 def void builtInEnumLiteralInNodeValueAssertionTest(String qualifiedName) {
296 val it = parseHelper.parse('''
297 «qualifiedName»: 16.
298 ''')
299 assertThat(errors, empty)
300 assertThat(nodes, empty)
301 assertThat(nodeValueAssertion(0).node, equalTo(builtin.findEnum("bool").literal("true")))
302 }
303
304 @ParameterizedTest
305 @MethodSource("builtInEnumLiteralReferencesSource")
306 def void bultInEnumLiteralInPredicateTest(String qualifiedName) {
307 val it = parseHelper.parse('''
308 pred predicate() <-> node(«qualifiedName»).
309 ''')
310 assertThat(errors, empty)
311 assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true")))
312 }
313
314 static def builtInEnumLiteralReferencesSource() {
315 Stream.of(
316 Arguments.of("true"),
317 Arguments.of("bool::true"),
318 Arguments.of("builtin::true"),
319 Arguments.of("builtin::bool::true")
320 )
321 }
322}
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 ba3aaeb7..ea858e92 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
@@ -22,7 +22,6 @@ import org.junit.jupiter.params.provider.MethodSource;
22 22
23import com.google.inject.Inject; 23import com.google.inject.Inject;
24 24
25import tools.refinery.language.model.ProblemUtil;
26import tools.refinery.language.model.problem.Atom; 25import tools.refinery.language.model.problem.Atom;
27import tools.refinery.language.model.problem.LogicValue; 26import tools.refinery.language.model.problem.LogicValue;
28import tools.refinery.language.model.problem.Node; 27import tools.refinery.language.model.problem.Node;
@@ -31,7 +30,7 @@ import tools.refinery.language.model.problem.Problem;
31import tools.refinery.language.model.problem.ProblemFactory; 30import tools.refinery.language.model.problem.ProblemFactory;
32import tools.refinery.language.model.problem.Relation; 31import tools.refinery.language.model.problem.Relation;
33import tools.refinery.language.model.problem.VariableOrNode; 32import tools.refinery.language.model.problem.VariableOrNode;
34import tools.refinery.language.model.tests.ProblemTestUtil; 33import tools.refinery.language.model.tests.utils.WrappedProblem;
35import tools.refinery.language.tests.ProblemInjectorProvider; 34import tools.refinery.language.tests.ProblemInjectorProvider;
36 35
37@ExtendWith(InjectionExtension.class) 36@ExtendWith(InjectionExtension.class)
@@ -40,21 +39,19 @@ class ProblemSerializerTest {
40 @Inject 39 @Inject
41 private ResourceSet resourceSet; 40 private ResourceSet resourceSet;
42 41
43 @Inject
44 private ProblemTestUtil testUtil;
45
46 private Resource resource; 42 private Resource resource;
47 43
48 private Problem problem; 44 private Problem problem;
49 45
50 private Problem builtin; 46 private WrappedProblem builtin;
51 47
52 @BeforeEach 48 @BeforeEach
53 void beforeEach() { 49 void beforeEach() {
54 problem = ProblemFactory.eINSTANCE.createProblem(); 50 problem = ProblemFactory.eINSTANCE.createProblem();
55 resource = resourceSet.createResource(URI.createFileURI("test.problem")); 51 resource = resourceSet.createResource(URI.createFileURI("test.problem"));
56 resource.getContents().add(problem); 52 resource.getContents().add(problem);
57 builtin = ProblemUtil.getBuiltInLibrary(problem).get(); 53 var wrappedProblem = new WrappedProblem(problem);
54 builtin = wrappedProblem.builtin();
58 } 55 }
59 56
60 @ParameterizedTest 57 @ParameterizedTest
@@ -99,8 +96,8 @@ class ProblemSerializerTest {
99 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition(); 96 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
100 pred.setName("foo"); 97 pred.setName("foo");
101 var parameter = ProblemFactory.eINSTANCE.createParameter(); 98 var parameter = ProblemFactory.eINSTANCE.createParameter();
102 var nodeType = testUtil.findClass(builtin, "node"); 99 var nodeType = builtin.findClass("node");
103 parameter.setParameterType(nodeType); 100 parameter.setParameterType(nodeType.get());
104 parameter.setName("p"); 101 parameter.setName("p");
105 pred.getParameters().add(parameter); 102 pred.getParameters().add(parameter);
106 problem.getStatements().add(pred); 103 problem.getStatements().add(pred);
@@ -142,20 +139,20 @@ class ProblemSerializerTest {
142 void implicitVariableTest() { 139 void implicitVariableTest() {
143 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition(); 140 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
144 pred.setName("foo"); 141 pred.setName("foo");
145 var nodeType = testUtil.findClass(builtin, "node"); 142 var nodeType = builtin.findClass("node");
146 var parameter1 = ProblemFactory.eINSTANCE.createParameter(); 143 var parameter1 = ProblemFactory.eINSTANCE.createParameter();
147 parameter1.setParameterType(nodeType); 144 parameter1.setParameterType(nodeType.get());
148 parameter1.setName("p1"); 145 parameter1.setName("p1");
149 pred.getParameters().add(parameter1); 146 pred.getParameters().add(parameter1);
150 var parameter2 = ProblemFactory.eINSTANCE.createParameter(); 147 var parameter2 = ProblemFactory.eINSTANCE.createParameter();
151 parameter2.setParameterType(nodeType); 148 parameter2.setParameterType(nodeType.get());
152 parameter2.setName("p2"); 149 parameter2.setName("p2");
153 pred.getParameters().add(parameter2); 150 pred.getParameters().add(parameter2);
154 var conjunction = ProblemFactory.eINSTANCE.createConjunction(); 151 var conjunction = ProblemFactory.eINSTANCE.createConjunction();
155 var variable = ProblemFactory.eINSTANCE.createImplicitVariable(); 152 var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
156 variable.setName("q"); 153 variable.setName("q");
157 conjunction.getImplicitVariables().add(variable); 154 conjunction.getImplicitVariables().add(variable);
158 var equals = testUtil.reference(nodeType, "equals"); 155 var equals = nodeType.reference("equals");
159 conjunction.getLiterals().add(createAtom(equals, parameter1, variable)); 156 conjunction.getLiterals().add(createAtom(equals, parameter1, variable));
160 conjunction.getLiterals().add(createAtom(equals, variable, parameter2)); 157 conjunction.getLiterals().add(createAtom(equals, variable, parameter2));
161 pred.getBodies().add(conjunction); 158 pred.getBodies().add(conjunction);
@@ -182,14 +179,14 @@ class ProblemSerializerTest {
182 void singletonVariableTest() { 179 void singletonVariableTest() {
183 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition(); 180 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
184 pred.setName("foo"); 181 pred.setName("foo");
185 var nodeType = testUtil.findClass(builtin, "node"); 182 var nodeType = builtin.findClass("node");
186 var parameter = ProblemFactory.eINSTANCE.createParameter(); 183 var parameter = ProblemFactory.eINSTANCE.createParameter();
187 parameter.setParameterType(nodeType); 184 parameter.setParameterType(nodeType.get());
188 parameter.setName("p"); 185 parameter.setName("p");
189 pred.getParameters().add(parameter); 186 pred.getParameters().add(parameter);
190 var conjunction = ProblemFactory.eINSTANCE.createConjunction(); 187 var conjunction = ProblemFactory.eINSTANCE.createConjunction();
191 var atom = ProblemFactory.eINSTANCE.createAtom(); 188 var atom = ProblemFactory.eINSTANCE.createAtom();
192 var equals = testUtil.reference(nodeType, "equals"); 189 var equals = nodeType.reference("equals");
193 atom.setRelation(equals); 190 atom.setRelation(equals);
194 var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument(); 191 var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
195 arg1.setVariableOrNode(parameter); 192 arg1.setVariableOrNode(parameter);
@@ -224,6 +221,6 @@ class ProblemSerializerTest {
224 } 221 }
225 var problemString = outputStream.toString(); 222 var problemString = outputStream.toString();
226 223
227 assertThat(problemString, equalTo(expected)); 224 assertThat(problemString.replace("\r\n", "\n"), equalTo(expected.replace("\r\n", "\n")));
228 } 225 }
229} 226}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-21 09:15:18 +0000