diff options
author | Kristóf Marussy <marussy@mit.bme.hu> | 2024-02-19 00:44:05 +0100 |
---|---|---|
committer | GitHub <noreply@github.com> | 2024-02-19 00:44:05 +0100 |
commit | 201c3da912aeaab8a3f51b84198b35c7936d0446 (patch) | |
tree | e427986134c41b540b10b9a9576f5a1788d8fbed /subprojects/language/src/test/java | |
parent | chore(deps): bump dependencies (diff) | |
parent | docs: update README (diff) | |
download | refinery-201c3da912aeaab8a3f51b84198b35c7936d0446.tar.gz refinery-201c3da912aeaab8a3f51b84198b35c7936d0446.tar.zst refinery-201c3da912aeaab8a3f51b84198b35c7936d0446.zip |
Merge pull request #53 from kris7t/imports
Module and import resolution support
Diffstat (limited to 'subprojects/language/src/test/java')
6 files changed, 191 insertions, 65 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 index 72d57f54..17ae5fbb 100644 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java | |||
@@ -42,7 +42,7 @@ class ProblemParsingTest { | |||
42 | error invalidTaxStatus(Person p) <-> | 42 | error invalidTaxStatus(Person p) <-> |
43 | taxStatus(p, CHILD), children(p, _q). | 43 | taxStatus(p, CHILD), children(p, _q). |
44 | 44 | ||
45 | indiv family. | 45 | atom family. |
46 | Family(family). | 46 | Family(family). |
47 | members(family, anne): true. | 47 | members(family, anne): true. |
48 | members(family, bob). | 48 | members(family, bob). |
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 f688d970..4a15f9de 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 | |||
@@ -183,8 +183,8 @@ class ProblemFormatterTest { | |||
183 | } | 183 | } |
184 | 184 | ||
185 | @Test | 185 | @Test |
186 | void individualDeclarationTest() { | 186 | void atomDeclarationTest() { |
187 | testFormatter(" indiv a , b . ", "indiv a, b.\n"); | 187 | testFormatter(" atom a , b . ", "atom a, b.\n"); |
188 | } | 188 | } |
189 | 189 | ||
190 | @Test | 190 | @Test |
@@ -194,7 +194,7 @@ class ProblemFormatterTest { | |||
194 | pred foo(node a). | 194 | pred foo(node a). |
195 | class Foo. | 195 | class Foo. |
196 | foo(n1, n2). | 196 | foo(n1, n2). |
197 | indiv i1. | 197 | atom i1. |
198 | !foo(i1, n1). | 198 | !foo(i1, n1). |
199 | pred bar(node a, node b). | 199 | pred bar(node a, node b). |
200 | pred quux(). | 200 | pred quux(). |
@@ -207,7 +207,7 @@ class ProblemFormatterTest { | |||
207 | class Foo. | 207 | class Foo. |
208 | 208 | ||
209 | foo(n1, n2). | 209 | foo(n1, n2). |
210 | indiv i1. | 210 | atom i1. |
211 | !foo(i1, n1). | 211 | !foo(i1, n1). |
212 | 212 | ||
213 | pred bar(node a, node b). | 213 | pred bar(node a, node b). |
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 index e76d2993..0704e026 100644 --- 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 | |||
@@ -1,5 +1,5 @@ | |||
1 | /* | 1 | /* |
2 | * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/> | 2 | * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/> |
3 | * | 3 | * |
4 | * SPDX-License-Identifier: EPL-2.0 | 4 | * SPDX-License-Identifier: EPL-2.0 |
5 | */ | 5 | */ |
@@ -68,37 +68,31 @@ class NodeScopingTest { | |||
68 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("b"))); | 68 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("b"))); |
69 | } | 69 | } |
70 | 70 | ||
71 | @ParameterizedTest | 71 | @Test |
72 | @MethodSource("individualNodeReferenceSource") | 72 | void atomNodeInAssertionTest() { |
73 | void individualNodeInAssertionTest(String qualifiedNamePrefix, boolean namedProblem) { | ||
74 | var problem = parse(""" | 73 | var problem = parse(""" |
75 | indiv a, b. | 74 | atom a, b. |
76 | pred predicate(node x, node y) <-> node(x). | 75 | pred predicate(node x, node y) <-> node(x). |
77 | predicate({PARAM}a, {PARAM}a). | 76 | predicate(a, a). |
78 | ?predicate({PARAM}a, {PARAM}b). | 77 | ?predicate(a, b). |
79 | """, qualifiedNamePrefix, namedProblem); | 78 | """); |
80 | assertThat(problem.getResourceErrors(), empty()); | 79 | assertThat(problem.getResourceErrors(), empty()); |
81 | assertThat(problem.nodeNames(), empty()); | 80 | assertThat(problem.nodeNames(), empty()); |
82 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.individualNode("a"))); | 81 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.atomNode("a"))); |
83 | assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.individualNode("a"))); | 82 | assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.atomNode("a"))); |
84 | assertThat(problem.assertion(1).arg(0).node(), equalTo(problem.individualNode("a"))); | 83 | assertThat(problem.assertion(1).arg(0).node(), equalTo(problem.atomNode("a"))); |
85 | assertThat(problem.assertion(1).arg(1).node(), equalTo(problem.individualNode("b"))); | 84 | assertThat(problem.assertion(1).arg(1).node(), equalTo(problem.atomNode("b"))); |
86 | } | 85 | } |
87 | 86 | ||
88 | @ParameterizedTest | 87 | @Test |
89 | @MethodSource("individualNodeReferenceSource") | 88 | void atomNodeInPredicateTest() { |
90 | void individualNodeInPredicateTest(String qualifiedNamePrefix, boolean namedProblem) { | ||
91 | var problem = parse(""" | 89 | var problem = parse(""" |
92 | indiv b. | 90 | atom b. |
93 | pred predicate(node a) <-> node({PARAM}b). | 91 | pred predicate(node a) <-> node(b). |
94 | """); | 92 | """); |
95 | assertThat(problem.getResourceErrors(), empty()); | 93 | assertThat(problem.getResourceErrors(), empty()); |
96 | assertThat(problem.nodeNames(), empty()); | 94 | assertThat(problem.nodeNames(), empty()); |
97 | assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.individualNode("b"))); | 95 | assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.atomNode("b"))); |
98 | } | ||
99 | |||
100 | static Stream<Arguments> individualNodeReferenceSource() { | ||
101 | return Stream.of(Arguments.of("", false), Arguments.of("", true), Arguments.of("test::", true)); | ||
102 | } | 96 | } |
103 | 97 | ||
104 | @Disabled("No nodes are present in builtin.problem currently") | 98 | @Disabled("No nodes are present in builtin.problem currently") |
@@ -131,37 +125,30 @@ class NodeScopingTest { | |||
131 | return Stream.of(Arguments.of("int::new"), Arguments.of("builtin::int::new")); | 125 | return Stream.of(Arguments.of("int::new"), Arguments.of("builtin::int::new")); |
132 | } | 126 | } |
133 | 127 | ||
134 | @ParameterizedTest | 128 | @Test |
135 | @MethodSource("classNewNodeReferencesSource") | 129 | void classNewNodeTest() { |
136 | void classNewNodeTest(String qualifiedName, boolean namedProblem) { | ||
137 | var problem = parse(""" | 130 | var problem = parse(""" |
138 | class Foo. | 131 | class Foo. |
139 | pred predicate(node x) <-> node(x). | 132 | pred predicate(node x) <-> node(x). |
140 | predicate({PARAM}). | 133 | predicate(Foo::new). |
141 | """, qualifiedName, namedProblem); | 134 | """); |
142 | assertThat(problem.getResourceErrors(), empty()); | 135 | assertThat(problem.getResourceErrors(), empty()); |
143 | assertThat(problem.nodeNames(), empty()); | 136 | assertThat(problem.nodeNames(), empty()); |
144 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findClass("Foo").get().getNewNode())); | 137 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findClass("Foo").get().getNewNode())); |
145 | } | 138 | } |
146 | 139 | ||
147 | @ParameterizedTest | 140 | @Test |
148 | @MethodSource("classNewNodeReferencesSource") | 141 | void classNewNodeInPredicateTest() { |
149 | void classNewNodeInPredicateTest(String qualifiedName, boolean namedProblem) { | ||
150 | var problem = parse(""" | 142 | var problem = parse(""" |
151 | class Foo. | 143 | class Foo. |
152 | pred predicate(node x) <-> node({PARAM}). | 144 | pred predicate(node x) <-> node(Foo::new). |
153 | """, qualifiedName, namedProblem); | 145 | """); |
154 | assertThat(problem.getResourceErrors(), empty()); | 146 | assertThat(problem.getResourceErrors(), empty()); |
155 | assertThat(problem.nodeNames(), empty()); | 147 | assertThat(problem.nodeNames(), empty()); |
156 | assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), | 148 | assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), |
157 | equalTo(problem.findClass("Foo").get().getNewNode())); | 149 | equalTo(problem.findClass("Foo").get().getNewNode())); |
158 | } | 150 | } |
159 | 151 | ||
160 | static Stream<Arguments> classNewNodeReferencesSource() { | ||
161 | return Stream.of(Arguments.of("Foo::new", false), Arguments.of("Foo::new", true), | ||
162 | Arguments.of("test::Foo::new", true)); | ||
163 | } | ||
164 | |||
165 | @Test | 152 | @Test |
166 | void newNodeIsNotSpecial() { | 153 | void newNodeIsNotSpecial() { |
167 | var problem = parse(""" | 154 | var problem = parse(""" |
@@ -176,12 +163,12 @@ class NodeScopingTest { | |||
176 | 163 | ||
177 | @ParameterizedTest | 164 | @ParameterizedTest |
178 | @MethodSource("enumLiteralReferencesSource") | 165 | @MethodSource("enumLiteralReferencesSource") |
179 | void enumLiteralTest(String qualifiedName, boolean namedProblem) { | 166 | void enumLiteralTest(String qualifiedName) { |
180 | var problem = parse(""" | 167 | var problem = parse(""" |
181 | enum Foo { alpha, beta } | 168 | enum Foo { alpha, beta } |
182 | pred predicate(Foo a) <-> node(a). | 169 | pred predicate(Foo a) <-> node(a). |
183 | predicate({PARAM}). | 170 | predicate({PARAM}). |
184 | """, qualifiedName, namedProblem); | 171 | """, qualifiedName); |
185 | assertThat(problem.getResourceErrors(), empty()); | 172 | assertThat(problem.getResourceErrors(), empty()); |
186 | assertThat(problem.nodeNames(), empty()); | 173 | assertThat(problem.nodeNames(), empty()); |
187 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findEnum("Foo").literal("alpha"))); | 174 | assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findEnum("Foo").literal("alpha"))); |
@@ -189,11 +176,11 @@ class NodeScopingTest { | |||
189 | 176 | ||
190 | @ParameterizedTest | 177 | @ParameterizedTest |
191 | @MethodSource("enumLiteralReferencesSource") | 178 | @MethodSource("enumLiteralReferencesSource") |
192 | void enumLiteralInPredicateTest(String qualifiedName, boolean namedProblem) { | 179 | void enumLiteralInPredicateTest(String qualifiedName) { |
193 | var problem = parse(""" | 180 | var problem = parse(""" |
194 | enum Foo { alpha, beta } | 181 | enum Foo { alpha, beta } |
195 | pred predicate(Foo a) <-> node({PARAM}). | 182 | pred predicate(Foo a) <-> node({PARAM}). |
196 | """, qualifiedName, namedProblem); | 183 | """, qualifiedName); |
197 | assertThat(problem.getResourceErrors(), empty()); | 184 | assertThat(problem.getResourceErrors(), empty()); |
198 | assertThat(problem.nodeNames(), empty()); | 185 | assertThat(problem.nodeNames(), empty()); |
199 | assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), | 186 | assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), |
@@ -201,9 +188,7 @@ class NodeScopingTest { | |||
201 | } | 188 | } |
202 | 189 | ||
203 | static Stream<Arguments> enumLiteralReferencesSource() { | 190 | static Stream<Arguments> enumLiteralReferencesSource() { |
204 | return Stream.of(Arguments.of("alpha", false), Arguments.of("alpha", true), Arguments.of("Foo::alpha", false), | 191 | return Stream.of(Arguments.of("alpha"), Arguments.of("Foo::alpha")); |
205 | Arguments.of("Foo::alpha", true), Arguments.of("test::alpha", true), | ||
206 | Arguments.of("test::Foo::alpha", true)); | ||
207 | } | 192 | } |
208 | 193 | ||
209 | @Disabled("No enum literals are present in builtin.problem currently") | 194 | @Disabled("No enum literals are present in builtin.problem currently") |
@@ -222,7 +207,7 @@ class NodeScopingTest { | |||
222 | @Disabled("No enum literals are present in builtin.problem currently") | 207 | @Disabled("No enum literals are present in builtin.problem currently") |
223 | @ParameterizedTest | 208 | @ParameterizedTest |
224 | @MethodSource("builtInEnumLiteralReferencesSource") | 209 | @MethodSource("builtInEnumLiteralReferencesSource") |
225 | void bultInEnumLiteralInPredicateTest(String qualifiedName) { | 210 | void builtInEnumLiteralInPredicateTest(String qualifiedName) { |
226 | var problem = parse(""" | 211 | var problem = parse(""" |
227 | pred predicate() <-> node({PARAM}). | 212 | pred predicate() <-> node({PARAM}). |
228 | """, qualifiedName); | 213 | """, qualifiedName); |
@@ -237,13 +222,8 @@ class NodeScopingTest { | |||
237 | Arguments.of("builtin::bool::true")); | 222 | Arguments.of("builtin::bool::true")); |
238 | } | 223 | } |
239 | 224 | ||
240 | private WrappedProblem parse(String text, String parameter, boolean namedProblem) { | ||
241 | var problemName = namedProblem ? "problem test.\n" : ""; | ||
242 | return parseHelper.parse(problemName + text.replace("{PARAM}", parameter)); | ||
243 | } | ||
244 | |||
245 | private WrappedProblem parse(String text, String parameter) { | 225 | private WrappedProblem parse(String text, String parameter) { |
246 | return parse(text, parameter, false); | 226 | return parseHelper.parse(text.replace("{PARAM}", parameter)); |
247 | } | 227 | } |
248 | 228 | ||
249 | private WrappedProblem parse(String text) { | 229 | private WrappedProblem parse(String text) { |
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 65675b6b..ad583f8e 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 | |||
@@ -56,15 +56,16 @@ class ProblemSerializerTest { | |||
56 | var pred = createPred(); | 56 | var pred = createPred(); |
57 | var node = ProblemFactory.eINSTANCE.createNode(); | 57 | var node = ProblemFactory.eINSTANCE.createNode(); |
58 | node.setName("a"); | 58 | node.setName("a"); |
59 | var individualDeclaration = ProblemFactory.eINSTANCE.createIndividualDeclaration(); | 59 | var atomDeclaration = ProblemFactory.eINSTANCE.createNodeDeclaration(); |
60 | individualDeclaration.getNodes().add(node); | 60 | atomDeclaration.setKind(NodeKind.ATOM); |
61 | problem.getStatements().add(individualDeclaration); | 61 | atomDeclaration.getNodes().add(node); |
62 | problem.getStatements().add(atomDeclaration); | ||
62 | createAssertion(pred, node, value); | 63 | createAssertion(pred, node, value); |
63 | 64 | ||
64 | assertSerializedResult(""" | 65 | assertSerializedResult(""" |
65 | pred foo(node p). | 66 | pred foo(node p). |
66 | 67 | ||
67 | indiv a. | 68 | atom a. |
68 | """ + serializedAssertion + "\n"); | 69 | """ + serializedAssertion + "\n"); |
69 | } | 70 | } |
70 | 71 | ||
@@ -79,15 +80,16 @@ class ProblemSerializerTest { | |||
79 | var pred = createPred(); | 80 | var pred = createPred(); |
80 | var node = ProblemFactory.eINSTANCE.createNode(); | 81 | var node = ProblemFactory.eINSTANCE.createNode(); |
81 | node.setName("a"); | 82 | node.setName("a"); |
82 | var individualDeclaration = ProblemFactory.eINSTANCE.createIndividualDeclaration(); | 83 | var atomDeclaration = ProblemFactory.eINSTANCE.createNodeDeclaration(); |
83 | individualDeclaration.getNodes().add(node); | 84 | atomDeclaration.setKind(NodeKind.ATOM); |
84 | problem.getStatements().add(individualDeclaration); | 85 | atomDeclaration.getNodes().add(node); |
86 | problem.getStatements().add(atomDeclaration); | ||
85 | createAssertion(pred, node, value, true); | 87 | createAssertion(pred, node, value, true); |
86 | 88 | ||
87 | assertSerializedResult(""" | 89 | assertSerializedResult(""" |
88 | pred foo(node p). | 90 | pred foo(node p). |
89 | 91 | ||
90 | indiv a. | 92 | atom a. |
91 | default\040""" + serializedAssertion + "\n"); | 93 | default\040""" + serializedAssertion + "\n"); |
92 | } | 94 | } |
93 | 95 | ||
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/AssertionValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/AssertionValidationTest.java index 82dea31b..1fb08845 100644 --- a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/AssertionValidationTest.java +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/AssertionValidationTest.java | |||
@@ -82,7 +82,6 @@ class AssertionValidationTest { | |||
82 | "exists(n).", | 82 | "exists(n).", |
83 | "?exists(n).", | 83 | "?exists(n).", |
84 | "!exists(n).", | 84 | "!exists(n).", |
85 | "exists(*).", | ||
86 | "?exists(*).", | 85 | "?exists(*).", |
87 | "exists(Foo::new).", | 86 | "exists(Foo::new).", |
88 | "?exists(Foo::new).", | 87 | "?exists(Foo::new).", |
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/ModuleValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/ModuleValidationTest.java new file mode 100644 index 00000000..00ad051b --- /dev/null +++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/ModuleValidationTest.java | |||
@@ -0,0 +1,145 @@ | |||
1 | /* | ||
2 | * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/> | ||
3 | * | ||
4 | * SPDX-License-Identifier: EPL-2.0 | ||
5 | */ | ||
6 | package tools.refinery.language.tests.validation; | ||
7 | |||
8 | import com.google.inject.Inject; | ||
9 | import org.eclipse.xtext.testing.InjectWith; | ||
10 | import org.eclipse.xtext.testing.extensions.InjectionExtension; | ||
11 | import org.junit.jupiter.api.Test; | ||
12 | import org.junit.jupiter.api.extension.ExtendWith; | ||
13 | import org.junit.jupiter.params.ParameterizedTest; | ||
14 | import org.junit.jupiter.params.provider.Arguments; | ||
15 | import org.junit.jupiter.params.provider.MethodSource; | ||
16 | import tools.refinery.language.model.tests.utils.ProblemParseHelper; | ||
17 | import tools.refinery.language.tests.ProblemInjectorProvider; | ||
18 | import tools.refinery.language.validation.ProblemValidator; | ||
19 | |||
20 | import java.util.stream.Stream; | ||
21 | |||
22 | import static org.hamcrest.MatcherAssert.assertThat; | ||
23 | import static org.hamcrest.Matchers.*; | ||
24 | |||
25 | @ExtendWith(InjectionExtension.class) | ||
26 | @InjectWith(ProblemInjectorProvider.class) | ||
27 | class ModuleValidationTest { | ||
28 | @Inject | ||
29 | private ProblemParseHelper parseHelper; | ||
30 | |||
31 | @ParameterizedTest | ||
32 | @MethodSource | ||
33 | void invalidMultiObjectExistsTest(String invalidDeclaration) { | ||
34 | var problem = parseHelper.parse(""" | ||
35 | module. | ||
36 | |||
37 | %s | ||
38 | """.formatted(invalidDeclaration)); | ||
39 | var issues = problem.validate(); | ||
40 | assertThat(issues, hasItem(hasProperty("issueCode", | ||
41 | is(ProblemValidator.UNSUPPORTED_ASSERTION_ISSUE)))); | ||
42 | } | ||
43 | |||
44 | static Stream<Arguments> invalidMultiObjectExistsTest() { | ||
45 | return Stream.of( | ||
46 | Arguments.of(""" | ||
47 | class Foo. | ||
48 | exists(Foo::new). | ||
49 | """), | ||
50 | Arguments.of(""" | ||
51 | multi m. | ||
52 | exists(m). | ||
53 | """)); | ||
54 | } | ||
55 | |||
56 | @Test | ||
57 | void invalidScopeTest() { | ||
58 | var problem = parseHelper.parse(""" | ||
59 | module. | ||
60 | |||
61 | class Foo. | ||
62 | scope Foo += 1. | ||
63 | """); | ||
64 | var issues = problem.validate(); | ||
65 | assertThat(issues, hasItem(hasProperty("issueCode", | ||
66 | is(ProblemValidator.INVALID_MULTIPLICITY_ISSUE)))); | ||
67 | } | ||
68 | |||
69 | @Test | ||
70 | void invalidAssertionArgumentTest() { | ||
71 | var problem = parseHelper.parse(""" | ||
72 | module. | ||
73 | |||
74 | class Foo. | ||
75 | Foo(foo1). | ||
76 | """); | ||
77 | var issues = problem.validate(); | ||
78 | assertThat(issues, hasItem(allOf( | ||
79 | hasProperty("issueCode", is(ProblemValidator.UNSUPPORTED_ASSERTION_ISSUE)), | ||
80 | hasProperty("message", containsString("foo1"))))); | ||
81 | } | ||
82 | |||
83 | @ParameterizedTest | ||
84 | @MethodSource | ||
85 | void validDeclarationTest(String validDeclaration) { | ||
86 | var problem = parseHelper.parse(validDeclaration); | ||
87 | var issues = problem.validate(); | ||
88 | assertThat(issues, hasSize(0)); | ||
89 | } | ||
90 | |||
91 | static Stream<Arguments> validDeclarationTest() { | ||
92 | return Stream.concat( | ||
93 | invalidMultiObjectExistsTest(), | ||
94 | Stream.of( | ||
95 | Arguments.of(""" | ||
96 | class Foo. | ||
97 | scope Foo += 1. | ||
98 | """), | ||
99 | Arguments.of(""" | ||
100 | module. | ||
101 | |||
102 | class Foo. | ||
103 | scope Foo = 1. | ||
104 | """), | ||
105 | Arguments.of(""" | ||
106 | class Foo. | ||
107 | Foo(foo1). | ||
108 | """), | ||
109 | Arguments.of(""" | ||
110 | module. | ||
111 | |||
112 | class Foo. | ||
113 | multi foo1. | ||
114 | Foo(foo1). | ||
115 | """), | ||
116 | Arguments.of(""" | ||
117 | module. | ||
118 | |||
119 | class Foo. | ||
120 | atom foo1. | ||
121 | Foo(foo1). | ||
122 | """), | ||
123 | Arguments.of(""" | ||
124 | module. | ||
125 | |||
126 | class Foo. | ||
127 | declare foo1. | ||
128 | Foo(foo1). | ||
129 | """), | ||
130 | Arguments.of(""" | ||
131 | module. | ||
132 | |||
133 | enum Foo { foo1 } | ||
134 | Foo(foo1). | ||
135 | """), | ||
136 | Arguments.of(""" | ||
137 | module. | ||
138 | |||
139 | class Foo. | ||
140 | Foo(Foo::new). | ||
141 | """) | ||
142 | ) | ||
143 | ); | ||
144 | } | ||
145 | } | ||