diff options
Diffstat (limited to 'Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra')
12 files changed, 1359 insertions, 0 deletions
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/CbcPolyhedronSolverTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/CbcPolyhedronSolverTest.xtend new file mode 100644 index 00000000..b22e2a20 --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/CbcPolyhedronSolverTest.xtend | |||
@@ -0,0 +1,42 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.cardinality | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.CbcPolyhedronSolver | ||
4 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Dimension | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Polyhedron | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronSaturationResult | ||
7 | import org.junit.Test | ||
8 | |||
9 | import static org.junit.Assert.* | ||
10 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearConstraint | ||
11 | |||
12 | class CbcPolyhedronSolverTest extends IntegerPolyhedronSolverTest { | ||
13 | |||
14 | override protected createSolver() { | ||
15 | new CbcPolyhedronSolver(false, 10, true) | ||
16 | } | ||
17 | } | ||
18 | |||
19 | class RelaxedCbcPolyhedronSolverTest extends RelaxedPolyhedronSolverTest { | ||
20 | |||
21 | override protected createSolver() { | ||
22 | new CbcPolyhedronSolver(true, 10, true) | ||
23 | } | ||
24 | } | ||
25 | |||
26 | class CbcPolyhedronSolverTimeoutTest { | ||
27 | |||
28 | @Test | ||
29 | def void timeoutTest() { | ||
30 | val solver = new CbcPolyhedronSolver(false, 0, true) | ||
31 | val x = new Dimension("x", 0, 1) | ||
32 | val polyhedron = new Polyhedron(#[x], #[new LinearConstraint(#{x -> 1}, null, 0)], #[x]) | ||
33 | val operator = solver.createSaturationOperator(polyhedron) | ||
34 | try { | ||
35 | val result = operator.saturate | ||
36 | |||
37 | assertEquals(PolyhedronSaturationResult.UNKNOWN, result) | ||
38 | } finally { | ||
39 | operator.close() | ||
40 | } | ||
41 | } | ||
42 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/PolyhedronSolverTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/PolyhedronSolverTest.xtend new file mode 100644 index 00000000..47534618 --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/PolyhedronSolverTest.xtend | |||
@@ -0,0 +1,385 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.cardinality | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Dimension | ||
4 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearConstraint | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Polyhedron | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronSaturationOperator | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronSaturationResult | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronSolver | ||
9 | import org.junit.After | ||
10 | import org.junit.Before | ||
11 | import org.junit.Test | ||
12 | |||
13 | import static org.junit.Assert.* | ||
14 | |||
15 | abstract class PolyhedronSolverTest { | ||
16 | var PolyhedronSolver solver | ||
17 | var PolyhedronSaturationOperator operator | ||
18 | |||
19 | protected def PolyhedronSolver createSolver() | ||
20 | |||
21 | @Before | ||
22 | def void setUp() { | ||
23 | solver = createSolver() | ||
24 | } | ||
25 | |||
26 | @After | ||
27 | def void tearDown() { | ||
28 | destroyOperatorIfExists() | ||
29 | } | ||
30 | |||
31 | @Test | ||
32 | def void singleDimensionTest() { | ||
33 | val x = new Dimension("x", 0, 1) | ||
34 | createSaturationOperator(new Polyhedron(#[x], #[], #[x])) | ||
35 | |||
36 | val result = saturate() | ||
37 | |||
38 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
39 | assertEquals(0, x.lowerBound) | ||
40 | assertEquals(1, x.upperBound) | ||
41 | } | ||
42 | |||
43 | @Test | ||
44 | def void singleDimensionNegativeValueTest() { | ||
45 | val x = new Dimension("x", -2, -1) | ||
46 | createSaturationOperator(new Polyhedron(#[x], #[], #[x])) | ||
47 | |||
48 | val result = saturate() | ||
49 | |||
50 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
51 | assertEquals(-2, x.lowerBound) | ||
52 | assertEquals(-1, x.upperBound) | ||
53 | } | ||
54 | |||
55 | @Test | ||
56 | def void singleDimensionConstraintTest() { | ||
57 | val x = new Dimension("x", null, null) | ||
58 | val constraint = new LinearConstraint(#{x -> 2}, 0, 2) | ||
59 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[x])) | ||
60 | |||
61 | val result = saturate() | ||
62 | |||
63 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
64 | assertEquals(0, x.lowerBound) | ||
65 | assertEquals(1, x.upperBound) | ||
66 | } | ||
67 | |||
68 | @Test | ||
69 | def void singleDimensionConstraintUnitCoefficientTest() { | ||
70 | val x = new Dimension("x", null, null) | ||
71 | val constraint = new LinearConstraint(#{x -> 1}, 1, 3) | ||
72 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[x])) | ||
73 | |||
74 | val result = saturate() | ||
75 | |||
76 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
77 | assertEquals(1, x.lowerBound) | ||
78 | assertEquals(3, x.upperBound) | ||
79 | } | ||
80 | |||
81 | @Test | ||
82 | def void singleDimensionUnboundedFromAboveTest() { | ||
83 | val x = new Dimension("x", -2, null) | ||
84 | createSaturationOperator(new Polyhedron(#[x], #[], #[x])) | ||
85 | |||
86 | val result = saturate() | ||
87 | |||
88 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
89 | assertEquals(-2, x.lowerBound) | ||
90 | assertEquals(null, x.upperBound) | ||
91 | } | ||
92 | |||
93 | @Test | ||
94 | def void singleDimensionUnboundedFromBelowTest() { | ||
95 | val x = new Dimension("x", null, 2) | ||
96 | createSaturationOperator(new Polyhedron(#[x], #[], #[x])) | ||
97 | |||
98 | val result = saturate() | ||
99 | |||
100 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
101 | assertEquals(null, x.lowerBound) | ||
102 | assertEquals(2, x.upperBound) | ||
103 | } | ||
104 | |||
105 | @Test | ||
106 | def void singleDimensionUnboundedTest() { | ||
107 | val x = new Dimension("x", null, null) | ||
108 | createSaturationOperator(new Polyhedron(#[x], #[], #[x])) | ||
109 | |||
110 | val result = saturate() | ||
111 | |||
112 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
113 | assertEquals(null, x.lowerBound) | ||
114 | assertEquals(null, x.upperBound) | ||
115 | } | ||
116 | |||
117 | @Test | ||
118 | def void singleDimensionUnboundedObjectiveTest() { | ||
119 | val x = new Dimension("x", null, null) | ||
120 | val y = new Dimension("y", 0, 1) | ||
121 | val objective = new LinearConstraint(#{x -> 1, y -> 1}, null, null) | ||
122 | createSaturationOperator(new Polyhedron(#[x, y], #[], #[objective])) | ||
123 | |||
124 | val result = saturate() | ||
125 | |||
126 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
127 | assertEquals(null, objective.lowerBound) | ||
128 | assertEquals(null, objective.upperBound) | ||
129 | } | ||
130 | |||
131 | @Test | ||
132 | def void singleDimensionUnsatisfiableTest() { | ||
133 | val x = new Dimension("x", 0, 1) | ||
134 | val constraint = new LinearConstraint(#{x -> 2}, -2, -1) | ||
135 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[x])) | ||
136 | |||
137 | val result = saturate() | ||
138 | |||
139 | assertEquals(PolyhedronSaturationResult.EMPTY, result) | ||
140 | } | ||
141 | |||
142 | @Test | ||
143 | def void equalityConstraintTest() { | ||
144 | val x = new Dimension("x", null, null) | ||
145 | val y = new Dimension("y", 1, 2) | ||
146 | val constraint = new LinearConstraint(#{x -> 2, y -> 2}, 6, 6) | ||
147 | createSaturationOperator(new Polyhedron(#[x, y], #[constraint], #[x])) | ||
148 | |||
149 | val result = saturate() | ||
150 | |||
151 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
152 | assertEquals(1, x.lowerBound) | ||
153 | assertEquals(2, x.upperBound) | ||
154 | } | ||
155 | |||
156 | @Test | ||
157 | def void saturateConstraintTest() { | ||
158 | val x = new Dimension("x", 0, 2) | ||
159 | val y = new Dimension("y", 1, 2) | ||
160 | val constraint = new LinearConstraint(#{x -> 2, y -> 1}, 0, 8) | ||
161 | createSaturationOperator(new Polyhedron(#[x, y], #[constraint], #[constraint])) | ||
162 | |||
163 | val result = saturate() | ||
164 | |||
165 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
166 | assertEquals(1, constraint.lowerBound) | ||
167 | assertEquals(6, constraint.upperBound) | ||
168 | } | ||
169 | |||
170 | @Test(expected=IllegalArgumentException) | ||
171 | def void unknownVariableTest() { | ||
172 | val x = new Dimension("x", 0, 1) | ||
173 | val y = new Dimension("y", 0, 1) | ||
174 | val constraint = new LinearConstraint(#{y -> 2}, 0, 2) | ||
175 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[x])) | ||
176 | |||
177 | saturate() | ||
178 | } | ||
179 | |||
180 | @Test | ||
181 | def void emptyConstraintTest() { | ||
182 | val x = new Dimension("x", 0, 1) | ||
183 | val constraint = new LinearConstraint(emptyMap, 0, 1) | ||
184 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[constraint])) | ||
185 | |||
186 | val result = saturate() | ||
187 | |||
188 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
189 | assertEquals(0, constraint.lowerBound) | ||
190 | assertEquals(0, constraint.upperBound) | ||
191 | } | ||
192 | |||
193 | @Test | ||
194 | def void emptyConstraintUnsatisfiableTest() { | ||
195 | val x = new Dimension("x", 0, 1) | ||
196 | val constraint = new LinearConstraint(emptyMap, 1, 0) | ||
197 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[constraint])) | ||
198 | |||
199 | val result = saturate() | ||
200 | |||
201 | assertEquals(PolyhedronSaturationResult.EMPTY, result) | ||
202 | } | ||
203 | |||
204 | @Test | ||
205 | def void unboundedRelaxationWithIntegerSolutionTest() { | ||
206 | val x = new Dimension("x", 1, 3) | ||
207 | val y = new Dimension("y", null, null) | ||
208 | createSaturationOperator(new Polyhedron( | ||
209 | #[x, y], | ||
210 | #[new LinearConstraint(#{x -> 2}, 2, 6)], | ||
211 | #[x, y] | ||
212 | )) | ||
213 | |||
214 | val result = saturate() | ||
215 | |||
216 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
217 | assertEquals(1, x.lowerBound) | ||
218 | assertEquals(3, x.upperBound) | ||
219 | assertEquals(null, y.lowerBound) | ||
220 | assertEquals(null, y.upperBound) | ||
221 | } | ||
222 | |||
223 | protected def createSaturationOperator(Polyhedron polyhedron) { | ||
224 | destroyOperatorIfExists() | ||
225 | operator = solver.createSaturationOperator(polyhedron) | ||
226 | } | ||
227 | |||
228 | protected def destroyOperatorIfExists() { | ||
229 | if (operator !== null) { | ||
230 | operator.close | ||
231 | } | ||
232 | } | ||
233 | |||
234 | protected def saturate() { | ||
235 | operator.saturate | ||
236 | } | ||
237 | } | ||
238 | |||
239 | abstract class IntegerPolyhedronSolverTest extends PolyhedronSolverTest { | ||
240 | @Test | ||
241 | def void singleDimensionConstraintNonIntegerTest() { | ||
242 | val x = new Dimension("x", null, null) | ||
243 | val constraint = new LinearConstraint(#{x -> 2}, 0, 3) | ||
244 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[x])) | ||
245 | |||
246 | val result = saturate() | ||
247 | |||
248 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
249 | assertEquals(0, x.lowerBound) | ||
250 | assertEquals(1, x.upperBound) | ||
251 | } | ||
252 | |||
253 | @Test | ||
254 | def void unsatisfiableMultipleInheritanceTest() { | ||
255 | val x = new Dimension("x", 0, 1) | ||
256 | val y = new Dimension("y", 0, 1) | ||
257 | val z = new Dimension("z", 0, 1) | ||
258 | createSaturationOperator(new Polyhedron( | ||
259 | #[x, y, z], | ||
260 | #[ | ||
261 | new LinearConstraint(#{x -> 1, y -> 1}, 1, 1), | ||
262 | new LinearConstraint(#{x -> 1, z -> 1}, 1, 1), | ||
263 | new LinearConstraint(#{y -> 1, z -> 1}, 1, 1) | ||
264 | ], | ||
265 | #[x, y, z] | ||
266 | )) | ||
267 | |||
268 | val result = saturate() | ||
269 | |||
270 | assertEquals(PolyhedronSaturationResult.EMPTY, result) | ||
271 | } | ||
272 | |||
273 | @Test | ||
274 | def void unboundedRelaxationWithNoIntegerSolutionTest() { | ||
275 | val x = new Dimension("x", 0, 1) | ||
276 | val y = new Dimension("y", null, null) | ||
277 | createSaturationOperator(new Polyhedron( | ||
278 | #[x, y], | ||
279 | #[new LinearConstraint(#{x -> 2}, 1, 1)], | ||
280 | #[x, y] | ||
281 | )) | ||
282 | |||
283 | val result = saturate() | ||
284 | |||
285 | assertEquals(PolyhedronSaturationResult.EMPTY, result) | ||
286 | } | ||
287 | } | ||
288 | |||
289 | abstract class RelaxedPolyhedronSolverTest extends PolyhedronSolverTest { | ||
290 | @Test | ||
291 | def void singleDimensionConstraintNonIntegerTest() { | ||
292 | val x = new Dimension("x", null, null) | ||
293 | val constraint = new LinearConstraint(#{x -> 2}, 0, 3) | ||
294 | createSaturationOperator(new Polyhedron(#[x], #[constraint], #[x])) | ||
295 | |||
296 | val result = saturate() | ||
297 | |||
298 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
299 | assertEquals(0, x.lowerBound) | ||
300 | assertEquals(2, x.upperBound) | ||
301 | } | ||
302 | |||
303 | @Test | ||
304 | def void unsatisfiableMultipleInheritanceTest() { | ||
305 | val x = new Dimension("x", 0, 1) | ||
306 | val y = new Dimension("y", 0, 1) | ||
307 | val z = new Dimension("z", 0, 1) | ||
308 | createSaturationOperator(new Polyhedron( | ||
309 | #[x, y, z], | ||
310 | #[ | ||
311 | new LinearConstraint(#{x -> 1, y -> 1}, 1, 1), | ||
312 | new LinearConstraint(#{x -> 1, z -> 1}, 1, 1), | ||
313 | new LinearConstraint(#{y -> 1, z -> 1}, 1, 1) | ||
314 | ], | ||
315 | #[x, y, z] | ||
316 | )) | ||
317 | |||
318 | val result = saturate() | ||
319 | |||
320 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
321 | assertEquals(0, x.lowerBound) | ||
322 | assertEquals(1, x.upperBound) | ||
323 | assertEquals(0, y.lowerBound) | ||
324 | assertEquals(1, y.upperBound) | ||
325 | assertEquals(0, z.lowerBound) | ||
326 | assertEquals(1, z.upperBound) | ||
327 | } | ||
328 | |||
329 | @Test | ||
330 | def void unboundedRelaxationWithNoIntegerSolutionUnconstrainedVariableTest() { | ||
331 | val x = new Dimension("x", 1, 2) | ||
332 | val y = new Dimension("y", null, null) | ||
333 | createSaturationOperator(new Polyhedron( | ||
334 | #[x, y], | ||
335 | #[new LinearConstraint(#{x -> 2}, 3, 3)], | ||
336 | #[x, y] | ||
337 | )) | ||
338 | |||
339 | val result = saturate() | ||
340 | |||
341 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
342 | assertEquals(1, x.lowerBound) | ||
343 | assertEquals(2, x.upperBound) | ||
344 | assertEquals(null, y.lowerBound) | ||
345 | assertEquals(null, y.upperBound) | ||
346 | } | ||
347 | |||
348 | @Test | ||
349 | def void unboundedRelaxationWithNoIntegerSolutionConstrainedVariableTest() { | ||
350 | val x = new Dimension("x", 1, 2) | ||
351 | val y = new Dimension("y", null, null) | ||
352 | createSaturationOperator(new Polyhedron( | ||
353 | #[x, y], | ||
354 | #[new LinearConstraint(#{x -> 2}, 3, 3), new LinearConstraint(#{y -> 1}, null, 1)], | ||
355 | #[x, y] | ||
356 | )) | ||
357 | |||
358 | val result = saturate() | ||
359 | |||
360 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
361 | assertEquals(1, x.lowerBound) | ||
362 | assertEquals(2, x.upperBound) | ||
363 | assertEquals(null, y.lowerBound) | ||
364 | assertEquals(1, y.upperBound) | ||
365 | } | ||
366 | |||
367 | @Test | ||
368 | def void unboundedRelaxationWithNoIntegerSolutionBoundedVariableTest() { | ||
369 | val x = new Dimension("x", 1, 2) | ||
370 | val y = new Dimension("y", null, 1) | ||
371 | createSaturationOperator(new Polyhedron( | ||
372 | #[x, y], | ||
373 | #[new LinearConstraint(#{x -> 2}, 3, 3)], | ||
374 | #[x, y] | ||
375 | )) | ||
376 | |||
377 | val result = saturate() | ||
378 | |||
379 | assertEquals(PolyhedronSaturationResult.SATURATED, result) | ||
380 | assertEquals(1, x.lowerBound) | ||
381 | assertEquals(2, x.upperBound) | ||
382 | assertEquals(null, y.lowerBound) | ||
383 | assertEquals(1, y.upperBound) | ||
384 | } | ||
385 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/Z3PolyhedronSolverTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/Z3PolyhedronSolverTest.xtend new file mode 100644 index 00000000..49b916d3 --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/cardinality/Z3PolyhedronSolverTest.xtend | |||
@@ -0,0 +1,17 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.cardinality | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Z3PolyhedronSolver | ||
4 | |||
5 | class Z3PolyhedronSolverTest extends IntegerPolyhedronSolverTest { | ||
6 | |||
7 | override protected createSolver() { | ||
8 | new Z3PolyhedronSolver(false, 10) | ||
9 | } | ||
10 | } | ||
11 | |||
12 | class RelaxedZ3PolyhedronSolverTest extends RelaxedPolyhedronSolverTest { | ||
13 | |||
14 | override protected createSolver() { | ||
15 | new Z3PolyhedronSolver(true, 10) | ||
16 | } | ||
17 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/AdditionTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/AdditionTest.xtend new file mode 100644 index 00000000..de5f40e1 --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/AdditionTest.xtend | |||
@@ -0,0 +1,49 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
4 | import java.util.Collection | ||
5 | import org.junit.Assert | ||
6 | import org.junit.Test | ||
7 | import org.junit.runner.RunWith | ||
8 | import org.junit.runners.Parameterized | ||
9 | import org.junit.runners.Parameterized.Parameter | ||
10 | import org.junit.runners.Parameterized.Parameters | ||
11 | |||
12 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
13 | |||
14 | @RunWith(Parameterized) | ||
15 | class AdditionTest { | ||
16 | @Parameters(name = "{index}: {0} + {1} = {2}") | ||
17 | static def Collection<Object[]> data() { | ||
18 | #[ | ||
19 | #[EMPTY, EMPTY, EMPTY], | ||
20 | #[EMPTY, between(-1, 1), EMPTY], | ||
21 | #[between(-1, 1), EMPTY, EMPTY], | ||
22 | #[UNBOUNDED, UNBOUNDED, UNBOUNDED], | ||
23 | #[UNBOUNDED, upTo(2), UNBOUNDED], | ||
24 | #[UNBOUNDED, above(-2), UNBOUNDED], | ||
25 | #[UNBOUNDED, between(-1, 1), UNBOUNDED], | ||
26 | #[upTo(2), UNBOUNDED, UNBOUNDED], | ||
27 | #[upTo(2), upTo(1), upTo(3)], | ||
28 | #[upTo(2), above(-1), UNBOUNDED], | ||
29 | #[upTo(2), between(-1, 2), upTo(4)], | ||
30 | #[above(-2), UNBOUNDED, UNBOUNDED], | ||
31 | #[above(-2), upTo(1), UNBOUNDED], | ||
32 | #[above(-2), above(-1), above(-3)], | ||
33 | #[above(-2), between(-1, 2), above(-3)], | ||
34 | #[between(-2, 3), UNBOUNDED, UNBOUNDED], | ||
35 | #[between(-2, 3), upTo(1), upTo(4)], | ||
36 | #[between(-2, 3), above(-1), above(-3)], | ||
37 | #[between(-2, 3), between(-1, 2.5), between(-3, 5.5)] | ||
38 | ] | ||
39 | } | ||
40 | |||
41 | @Parameter(0) public var Interval a | ||
42 | @Parameter(1) public var Interval b | ||
43 | @Parameter(2) public var Interval result | ||
44 | |||
45 | @Test | ||
46 | def void additionTest() { | ||
47 | Assert.assertEquals(result, a + b) | ||
48 | } | ||
49 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/DivisionTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/DivisionTest.xtend new file mode 100644 index 00000000..3a8c0c5d --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/DivisionTest.xtend | |||
@@ -0,0 +1,202 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
4 | import java.util.Collection | ||
5 | import org.junit.Assert | ||
6 | import org.junit.Test | ||
7 | import org.junit.runner.RunWith | ||
8 | import org.junit.runners.Parameterized | ||
9 | import org.junit.runners.Parameterized.Parameter | ||
10 | import org.junit.runners.Parameterized.Parameters | ||
11 | |||
12 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
13 | |||
14 | @RunWith(Parameterized) | ||
15 | class DivisionTest { | ||
16 | @Parameters(name="{index}: {0} / {1} = {2}") | ||
17 | static def Collection<Object[]> data() { | ||
18 | #[ | ||
19 | #[EMPTY, EMPTY, EMPTY], | ||
20 | #[EMPTY, between(-1, 1), EMPTY], | ||
21 | #[between(-1, 1), EMPTY, EMPTY], | ||
22 | #[UNBOUNDED, UNBOUNDED, UNBOUNDED], | ||
23 | #[UNBOUNDED, upTo(-2), UNBOUNDED], | ||
24 | #[UNBOUNDED, upTo(0), UNBOUNDED], | ||
25 | #[UNBOUNDED, upTo(3), UNBOUNDED], | ||
26 | #[UNBOUNDED, above(-2), UNBOUNDED], | ||
27 | #[UNBOUNDED, above(0), UNBOUNDED], | ||
28 | #[UNBOUNDED, above(3), UNBOUNDED], | ||
29 | #[UNBOUNDED, between(-4, -3), UNBOUNDED], | ||
30 | #[UNBOUNDED, between(-4, 0), UNBOUNDED], | ||
31 | #[UNBOUNDED, between(-3, 4), UNBOUNDED], | ||
32 | #[UNBOUNDED, between(0, 4), UNBOUNDED], | ||
33 | #[UNBOUNDED, between(3, 4), UNBOUNDED], | ||
34 | #[UNBOUNDED, ZERO, EMPTY], | ||
35 | #[upTo(-12), UNBOUNDED, UNBOUNDED], | ||
36 | #[upTo(-12), upTo(-2), above(0)], | ||
37 | #[upTo(-12), upTo(0), above(0)], | ||
38 | #[upTo(-12), upTo(3), UNBOUNDED], | ||
39 | #[upTo(-12), above(-2), UNBOUNDED], | ||
40 | #[upTo(-12), above(0), upTo(0)], | ||
41 | #[upTo(-12), above(3), upTo(0)], | ||
42 | #[upTo(-12), between(-4, -3), above(3)], | ||
43 | #[upTo(-12), between(-4, 0), above(3)], | ||
44 | #[upTo(-12), between(-3, 4), UNBOUNDED], | ||
45 | #[upTo(-12), between(0, 4), upTo(-3)], | ||
46 | #[upTo(-12), between(3, 4), upTo(-3)], | ||
47 | #[upTo(-12), ZERO, EMPTY], | ||
48 | #[upTo(0), UNBOUNDED, UNBOUNDED], | ||
49 | #[upTo(0), upTo(-2), above(0)], | ||
50 | #[upTo(0), upTo(0), above(0)], | ||
51 | #[upTo(0), upTo(3), UNBOUNDED], | ||
52 | #[upTo(0), above(-2), UNBOUNDED], | ||
53 | #[upTo(0), above(0), upTo(0)], | ||
54 | #[upTo(0), above(3), upTo(0)], | ||
55 | #[upTo(0), between(-4, -3), above(0)], | ||
56 | #[upTo(0), between(-4, 0), above(0)], | ||
57 | #[upTo(0), between(-3, 4), UNBOUNDED], | ||
58 | #[upTo(0), between(0, 4), upTo(0)], | ||
59 | #[upTo(0), between(3, 4), upTo(0)], | ||
60 | #[upTo(0), ZERO, EMPTY], | ||
61 | #[upTo(12), UNBOUNDED, UNBOUNDED], | ||
62 | #[upTo(12), upTo(-2), above(-6)], | ||
63 | #[upTo(12), upTo(0), UNBOUNDED], | ||
64 | #[upTo(12), upTo(3), UNBOUNDED], | ||
65 | #[upTo(12), above(-2), UNBOUNDED], | ||
66 | #[upTo(12), above(0), UNBOUNDED], | ||
67 | #[upTo(12), above(3), upTo(4)], | ||
68 | #[upTo(12), between(-4, -3), above(-4)], | ||
69 | #[upTo(12), between(-4, 0), UNBOUNDED], | ||
70 | #[upTo(12), between(-3, 4), UNBOUNDED], | ||
71 | #[upTo(12), between(0, 4), UNBOUNDED], | ||
72 | #[upTo(12), between(3, 4), upTo(4)], | ||
73 | #[upTo(12), ZERO, EMPTY], | ||
74 | #[above(-12), UNBOUNDED, UNBOUNDED], | ||
75 | #[above(-12), upTo(-2), upTo(6)], | ||
76 | #[above(-12), upTo(0), UNBOUNDED], | ||
77 | #[above(-12), upTo(3), UNBOUNDED], | ||
78 | #[above(-12), above(-2), UNBOUNDED], | ||
79 | #[above(-12), above(0), UNBOUNDED], | ||
80 | #[above(-12), above(3), above(-4)], | ||
81 | #[above(-12), between(-4, -3), upTo(4)], | ||
82 | #[above(-12), between(-4, 0), UNBOUNDED], | ||
83 | #[above(-12), between(-3, 4), UNBOUNDED], | ||
84 | #[above(-12), between(0, 4), UNBOUNDED], | ||
85 | #[above(-12), between(3, 4), above(-4)], | ||
86 | #[above(-12), ZERO, EMPTY], | ||
87 | #[above(0), UNBOUNDED, UNBOUNDED], | ||
88 | #[above(0), upTo(-2), upTo(0)], | ||
89 | #[above(0), upTo(0), upTo(0)], | ||
90 | #[above(0), upTo(3), UNBOUNDED], | ||
91 | #[above(0), above(-2), UNBOUNDED], | ||
92 | #[above(0), above(0), above(0)], | ||
93 | #[above(0), above(3), above(0)], | ||
94 | #[above(0), between(-4, -3), upTo(0)], | ||
95 | #[above(0), between(-4, 0), upTo(0)], | ||
96 | #[above(0), between(-3, 4), UNBOUNDED], | ||
97 | #[above(0), between(0, 4), above(0)], | ||
98 | #[above(0), between(3, 4), above(0)], | ||
99 | #[above(0), ZERO, EMPTY], | ||
100 | #[above(12), UNBOUNDED, UNBOUNDED], | ||
101 | #[above(12), upTo(-2), upTo(0)], | ||
102 | #[above(12), upTo(0), upTo(0)], | ||
103 | #[above(12), upTo(3), UNBOUNDED], | ||
104 | #[above(12), above(-2), UNBOUNDED], | ||
105 | #[above(12), above(0), above(0)], | ||
106 | #[above(12), above(3), above(0)], | ||
107 | #[above(12), between(-4, -3), upTo(-3)], | ||
108 | #[above(12), between(-4, 0), upTo(-3)], | ||
109 | #[above(12), between(-3, 4), UNBOUNDED], | ||
110 | #[above(12), between(0, 4), above(3)], | ||
111 | #[above(12), between(3, 4), above(3)], | ||
112 | #[above(12), ZERO, EMPTY], | ||
113 | #[between(-36, -12), UNBOUNDED, UNBOUNDED], | ||
114 | #[between(-36, -12), upTo(-2), between(0, 18)], | ||
115 | #[between(-36, -12), upTo(0), above(0)], | ||
116 | #[between(-36, -12), upTo(3), UNBOUNDED], | ||
117 | #[between(-36, -12), above(-2), UNBOUNDED], | ||
118 | #[between(-36, -12), above(0), upTo(0)], | ||
119 | #[between(-36, -12), above(3), between(-12, 0)], | ||
120 | #[between(-36, -12), between(-4, -3), between(3, 12)], | ||
121 | #[between(-36, -12), between(-4, 0), above(3)], | ||
122 | #[between(-36, -12), between(-3, 4), UNBOUNDED], | ||
123 | #[between(-36, -12), between(0, 4), upTo(-3)], | ||
124 | #[between(-36, -12), between(3, 4), between(-12, -3)], | ||
125 | #[between(-36, -12), ZERO, EMPTY], | ||
126 | #[between(-36, 0), UNBOUNDED, UNBOUNDED], | ||
127 | #[between(-36, 0), upTo(-2), between(0, 18)], | ||
128 | #[between(-36, 0), upTo(0), above(0)], | ||
129 | #[between(-36, 0), upTo(3), UNBOUNDED], | ||
130 | #[between(-36, 0), above(-2), UNBOUNDED], | ||
131 | #[between(-36, 0), above(0), upTo(0)], | ||
132 | #[between(-36, 0), above(3), between(-12, 0)], | ||
133 | #[between(-36, 0), between(-4, -3), between(0, 12)], | ||
134 | #[between(-36, 0), between(-4, 0), above(0)], | ||
135 | #[between(-36, 0), between(-3, 4), UNBOUNDED], | ||
136 | #[between(-36, 0), between(0, 4), upTo(0)], | ||
137 | #[between(-36, 0), between(3, 4), between(-12, 0)], | ||
138 | #[between(-36, 0), ZERO, EMPTY], | ||
139 | #[between(-12, 36), UNBOUNDED, UNBOUNDED], | ||
140 | #[between(-12, 36), upTo(-2), between(-18, 6)], | ||
141 | #[between(-12, 36), upTo(0), UNBOUNDED], | ||
142 | #[between(-12, 36), upTo(3), UNBOUNDED], | ||
143 | #[between(-12, 36), above(-2), UNBOUNDED], | ||
144 | #[between(-12, 36), above(0), UNBOUNDED], | ||
145 | #[between(-12, 36), above(3), between(-4, 12)], | ||
146 | #[between(-12, 36), between(-4, -3), between(-12, 4)], | ||
147 | #[between(-12, 36), between(-4, 0), UNBOUNDED], | ||
148 | #[between(-12, 36), between(-3, 4), UNBOUNDED], | ||
149 | #[between(-12, 36), between(0, 4), UNBOUNDED], | ||
150 | #[between(-12, 36), between(3, 4), between(-4, 12)], | ||
151 | #[between(-12, 36), ZERO, EMPTY], | ||
152 | #[between(0, 36), UNBOUNDED, UNBOUNDED], | ||
153 | #[between(0, 36), upTo(-2), between(-18, 0)], | ||
154 | #[between(0, 36), upTo(0), upTo(0)], | ||
155 | #[between(0, 36), upTo(3), UNBOUNDED], | ||
156 | #[between(0, 36), above(-2), UNBOUNDED], | ||
157 | #[between(0, 36), above(0), above(0)], | ||
158 | #[between(0, 36), above(3), between(0, 12)], | ||
159 | #[between(0, 36), between(-4, -3), between(-12, 0)], | ||
160 | #[between(0, 36), between(-4, 0), upTo(0)], | ||
161 | #[between(0, 36), between(-3, 4), UNBOUNDED], | ||
162 | #[between(0, 36), between(0, 4), above(0)], | ||
163 | #[between(0, 36), between(3, 4), between(0, 12)], | ||
164 | #[between(0, 36), ZERO, EMPTY], | ||
165 | #[between(12, 36), UNBOUNDED, UNBOUNDED], | ||
166 | #[between(12, 36), upTo(-2), between(-18, 0)], | ||
167 | #[between(12, 36), upTo(0), upTo(0)], | ||
168 | #[between(12, 36), upTo(3), UNBOUNDED], | ||
169 | #[between(12, 36), above(-2), UNBOUNDED], | ||
170 | #[between(12, 36), above(0), above(0)], | ||
171 | #[between(12, 36), above(3), between(0, 12)], | ||
172 | #[between(12, 36), between(-4, -3), between(-12, -3)], | ||
173 | #[between(12, 36), between(-4, 0), upTo(-3)], | ||
174 | #[between(12, 36), between(-3, 4), UNBOUNDED], | ||
175 | #[between(12, 36), between(0, 4), above(3)], | ||
176 | #[between(12, 36), between(3, 4), between(3, 12)], | ||
177 | #[between(12, 36), ZERO, EMPTY], | ||
178 | #[ZERO, UNBOUNDED, ZERO], | ||
179 | #[ZERO, upTo(-2), ZERO], | ||
180 | #[ZERO, upTo(0), ZERO], | ||
181 | #[ZERO, upTo(3), ZERO], | ||
182 | #[ZERO, above(-2), ZERO], | ||
183 | #[ZERO, above(0), ZERO], | ||
184 | #[ZERO, above(3), ZERO], | ||
185 | #[ZERO, between(-4, -3), ZERO], | ||
186 | #[ZERO, between(-4, 0), ZERO], | ||
187 | #[ZERO, between(-3, 4), ZERO], | ||
188 | #[ZERO, between(0, 4), ZERO], | ||
189 | #[ZERO, between(3, 4), ZERO], | ||
190 | #[ZERO, ZERO, EMPTY] | ||
191 | ] | ||
192 | } | ||
193 | |||
194 | @Parameter(0) public var Interval a | ||
195 | @Parameter(1) public var Interval b | ||
196 | @Parameter(2) public var Interval result | ||
197 | |||
198 | @Test | ||
199 | def void divisionTest() { | ||
200 | Assert.assertEquals(result, a / b) | ||
201 | } | ||
202 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MinAggregatorTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MinAggregatorTest.xtend new file mode 100644 index 00000000..7d46e16c --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MinAggregatorTest.xtend | |||
@@ -0,0 +1,67 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import com.google.common.collect.HashMultiset | ||
4 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationMode | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationOperator | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalRedBlackNode | ||
8 | import java.math.BigDecimal | ||
9 | import java.util.Random | ||
10 | import org.junit.Assert | ||
11 | import org.junit.Before | ||
12 | import org.junit.Test | ||
13 | |||
14 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
15 | |||
16 | class MinAggregatorTest { | ||
17 | val aggregator = new IntervalAggregationOperator(IntervalAggregationMode.MIN) | ||
18 | var IntervalRedBlackNode value = null | ||
19 | |||
20 | @Before | ||
21 | def void reset() { | ||
22 | value = aggregator.createNeutral | ||
23 | } | ||
24 | |||
25 | @Test | ||
26 | def void emptyTest() { | ||
27 | assertEquals(EMPTY) | ||
28 | } | ||
29 | |||
30 | @Test | ||
31 | def void largeTest() { | ||
32 | val starts = #[null, new BigDecimal(-3), new BigDecimal(-2), new BigDecimal(-1)] | ||
33 | val ends = #[new BigDecimal(1), new BigDecimal(2), new BigDecimal(3), null] | ||
34 | val current = HashMultiset.create | ||
35 | val random = new Random(1) | ||
36 | for (var int i = 0; i < 1000; i++) { | ||
37 | val start = starts.get(random.nextInt(starts.size)) | ||
38 | val end = ends.get(random.nextInt(ends.size)) | ||
39 | val interval = Interval.of(start, end) | ||
40 | val isInsert = !current.contains(interval) || random.nextInt(3) == 0 | ||
41 | if (isInsert) { | ||
42 | current.add(interval) | ||
43 | } else { | ||
44 | current.remove(interval) | ||
45 | } | ||
46 | val expected = current.stream.reduce(aggregator.mode).orElse(EMPTY) | ||
47 | update(interval, isInsert) | ||
48 | assertEquals(expected) | ||
49 | } | ||
50 | } | ||
51 | |||
52 | private def update(Interval interval, boolean isInsert) { | ||
53 | value = aggregator.update(value, interval, isInsert) | ||
54 | val nodes = newArrayList | ||
55 | var node = value.min | ||
56 | while (node !== null) { | ||
57 | nodes += node | ||
58 | node = node.successor | ||
59 | } | ||
60 | value.assertSubtreeIsValid | ||
61 | } | ||
62 | |||
63 | private def assertEquals(Interval interval) { | ||
64 | val actual = aggregator.getAggregate(value) | ||
65 | Assert.assertEquals(interval, actual) | ||
66 | } | ||
67 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MultiplicationTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MultiplicationTest.xtend new file mode 100644 index 00000000..5f997094 --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/MultiplicationTest.xtend | |||
@@ -0,0 +1,205 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
4 | import java.util.Collection | ||
5 | import org.junit.Assert | ||
6 | import org.junit.Test | ||
7 | import org.junit.runner.RunWith | ||
8 | import org.junit.runners.Parameterized | ||
9 | import org.junit.runners.Parameterized.Parameter | ||
10 | import org.junit.runners.Parameterized.Parameters | ||
11 | |||
12 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
13 | |||
14 | @RunWith(Parameterized) | ||
15 | class MultiplicationTest { | ||
16 | @Parameters(name="{index}: {0} * {1} = {2}") | ||
17 | static def Collection<Object[]> data() { | ||
18 | #[ | ||
19 | #[EMPTY, EMPTY, EMPTY], | ||
20 | #[EMPTY, between(-1, 1), EMPTY], | ||
21 | #[between(-1, 1), EMPTY, EMPTY], | ||
22 | #[UNBOUNDED, UNBOUNDED, UNBOUNDED], | ||
23 | #[UNBOUNDED, upTo(-2), UNBOUNDED], | ||
24 | #[UNBOUNDED, upTo(0), UNBOUNDED], | ||
25 | #[UNBOUNDED, upTo(3), UNBOUNDED], | ||
26 | #[UNBOUNDED, above(-2), UNBOUNDED], | ||
27 | #[UNBOUNDED, above(0), UNBOUNDED], | ||
28 | #[UNBOUNDED, above(3), UNBOUNDED], | ||
29 | #[UNBOUNDED, between(-4, -3), UNBOUNDED], | ||
30 | #[UNBOUNDED, between(-4, 0), UNBOUNDED], | ||
31 | #[UNBOUNDED, between(-3, 4), UNBOUNDED], | ||
32 | #[UNBOUNDED, between(0, 4), UNBOUNDED], | ||
33 | #[UNBOUNDED, between(3, 4), UNBOUNDED], | ||
34 | #[UNBOUNDED, ZERO, ZERO], | ||
35 | #[upTo(-5), UNBOUNDED, UNBOUNDED], | ||
36 | #[upTo(-5), upTo(-2), above(10)], | ||
37 | #[upTo(-5), upTo(0), above(0)], | ||
38 | #[upTo(-5), upTo(3), UNBOUNDED], | ||
39 | #[upTo(-5), above(-2), UNBOUNDED], | ||
40 | #[upTo(-5), above(0), upTo(0)], | ||
41 | #[upTo(-5), above(3), upTo(-15)], | ||
42 | #[upTo(-5), between(-4, -3), above(15)], | ||
43 | #[upTo(-5), between(-4, 0), above(0)], | ||
44 | #[upTo(-5), between(-3, 4), UNBOUNDED], | ||
45 | #[upTo(-5), between(0, 4), upTo(0)], | ||
46 | #[upTo(-5), between(3, 4), upTo(-15)], | ||
47 | #[upTo(-5), ZERO, ZERO], | ||
48 | #[upTo(0), UNBOUNDED, UNBOUNDED], | ||
49 | #[upTo(0), upTo(-2), above(0)], | ||
50 | #[upTo(0), upTo(0), above(0)], | ||
51 | #[upTo(0), upTo(3), UNBOUNDED], | ||
52 | #[upTo(0), above(-2), UNBOUNDED], | ||
53 | #[upTo(0), above(0), upTo(0)], | ||
54 | #[upTo(0), above(3), upTo(0)], | ||
55 | #[upTo(0), between(-4, -3), above(0)], | ||
56 | #[upTo(0), between(-4, 0), above(0)], | ||
57 | #[upTo(0), between(-3, 4), UNBOUNDED], | ||
58 | #[upTo(0), between(0, 4), upTo(0)], | ||
59 | #[upTo(0), between(3, 4), upTo(0)], | ||
60 | #[upTo(0), ZERO, ZERO], | ||
61 | #[upTo(5), UNBOUNDED, UNBOUNDED], | ||
62 | #[upTo(5), upTo(-2), UNBOUNDED], | ||
63 | #[upTo(5), upTo(0), UNBOUNDED], | ||
64 | #[upTo(5), upTo(3), UNBOUNDED], | ||
65 | #[upTo(5), above(-2), UNBOUNDED], | ||
66 | #[upTo(5), above(0), UNBOUNDED], | ||
67 | #[upTo(5), above(3), UNBOUNDED], | ||
68 | #[upTo(5), between(-4, -3), above(-20)], | ||
69 | #[upTo(5), between(-4, 0), above(-20)], | ||
70 | #[upTo(5), between(-3, 4), UNBOUNDED], | ||
71 | #[upTo(5), between(0, 4), upTo(20)], | ||
72 | #[upTo(5), between(3, 4), upTo(20)], | ||
73 | #[upTo(5), ZERO, ZERO], | ||
74 | #[above(-5), UNBOUNDED, UNBOUNDED], | ||
75 | #[above(-5), upTo(-2), UNBOUNDED], | ||
76 | #[above(-5), upTo(0), UNBOUNDED], | ||
77 | #[above(-5), upTo(3), UNBOUNDED], | ||
78 | #[above(-5), above(-2), UNBOUNDED], | ||
79 | #[above(-5), above(0), UNBOUNDED], | ||
80 | #[above(-5), above(3), UNBOUNDED], | ||
81 | #[above(-5), between(-4, -3), upTo(20)], | ||
82 | #[above(-5), between(-4, 0), upTo(20)], | ||
83 | #[above(-5), between(-3, 4), UNBOUNDED], | ||
84 | #[above(-5), between(0, 4), above(-20)], | ||
85 | #[above(-5), between(3, 4), above(-20)], | ||
86 | #[above(-5), ZERO, ZERO], | ||
87 | #[above(0), UNBOUNDED, UNBOUNDED], | ||
88 | #[above(0), upTo(-2), upTo(0)], | ||
89 | #[above(0), upTo(0), upTo(0)], | ||
90 | #[above(0), upTo(3), UNBOUNDED], | ||
91 | #[above(0), above(-2), UNBOUNDED], | ||
92 | #[above(0), above(0), above(0)], | ||
93 | #[above(0), above(3), above(0)], | ||
94 | #[above(0), between(-4, -3), upTo(0)], | ||
95 | #[above(0), between(-4, 0), upTo(0)], | ||
96 | #[above(0), between(-3, 4), UNBOUNDED], | ||
97 | #[above(0), between(0, 4), above(0)], | ||
98 | #[above(0), between(3, 4), above(0)], | ||
99 | #[above(0), ZERO, ZERO], | ||
100 | #[above(5), UNBOUNDED, UNBOUNDED], | ||
101 | #[above(5), upTo(-2), upTo(-10)], | ||
102 | #[above(5), upTo(0), upTo(0)], | ||
103 | #[above(5), upTo(3), UNBOUNDED], | ||
104 | #[above(5), above(-2), UNBOUNDED], | ||
105 | #[above(5), above(0), above(0)], | ||
106 | #[above(5), above(3), above(15)], | ||
107 | #[above(5), between(-4, -3), upTo(-15)], | ||
108 | #[above(5), between(-4, 0), upTo(0)], | ||
109 | #[above(5), between(-3, 4), UNBOUNDED], | ||
110 | #[above(5), between(0, 4), above(0)], | ||
111 | #[above(5), between(3, 4), above(15)], | ||
112 | #[above(5), ZERO, ZERO], | ||
113 | #[between(-6, -5), UNBOUNDED, UNBOUNDED], | ||
114 | #[between(-6, -5), upTo(-2), above(10)], | ||
115 | #[between(-6, -5), upTo(0), above(0)], | ||
116 | #[between(-6, -5), upTo(3), above(-18)], | ||
117 | #[between(-6, -5), above(-2), upTo(12)], | ||
118 | #[between(-6, -5), above(0), upTo(0)], | ||
119 | #[between(-6, -5), above(3), upTo(-15)], | ||
120 | #[between(-6, -5), between(-4, -3), between(15, 24)], | ||
121 | #[between(-6, -5), between(-4, 0), between(0, 24)], | ||
122 | #[between(-6, -5), between(-3, 4), between(-24, 18)], | ||
123 | #[between(-6, -5), between(0, 4), between(-24, 0)], | ||
124 | #[between(-6, -5), between(3, 4), between(-24, -15)], | ||
125 | #[between(-6, -5), ZERO, ZERO], | ||
126 | #[between(-6, 0), UNBOUNDED, UNBOUNDED], | ||
127 | #[between(-6, 0), upTo(-2), above(0)], | ||
128 | #[between(-6, 0), upTo(0), above(0)], | ||
129 | #[between(-6, 0), upTo(3), above(-18)], | ||
130 | #[between(-6, 0), above(-2), upTo(12)], | ||
131 | #[between(-6, 0), above(0), upTo(0)], | ||
132 | #[between(-6, 0), above(3), upTo(0)], | ||
133 | #[between(-6, 0), between(-4, -3), between(0, 24)], | ||
134 | #[between(-6, 0), between(-4, 0), between(0, 24)], | ||
135 | #[between(-6, 0), between(-3, 4), between(-24, 18)], | ||
136 | #[between(-6, 0), between(0, 4), between(-24, 0)], | ||
137 | #[between(-6, 0), between(3, 4), between(-24, 0)], | ||
138 | #[between(-6, 0), ZERO, ZERO], | ||
139 | #[between(-5, 6), UNBOUNDED, UNBOUNDED], | ||
140 | #[between(-5, 6), upTo(-2), UNBOUNDED], | ||
141 | #[between(-5, 6), upTo(0), UNBOUNDED], | ||
142 | #[between(-5, 6), upTo(3), UNBOUNDED], | ||
143 | #[between(-5, 6), above(-2), UNBOUNDED], | ||
144 | #[between(-5, 6), above(0), UNBOUNDED], | ||
145 | #[between(-5, 6), above(3), UNBOUNDED], | ||
146 | #[between(-5, 6), between(-4, -3), between(-24, 20)], | ||
147 | #[between(-5, 6), between(-4, 0), between(-24, 20)], | ||
148 | #[between(-5, 6), between(-3, 4), between(-20, 24)], | ||
149 | #[between(-5, 6), between(-3, 2), between(-18, 15)], | ||
150 | #[between(-5, 1), between(-3, 4), between(-20, 15)], | ||
151 | #[between(-5, 1), between(-3, 2), between(-10, 15)], | ||
152 | #[between(-5, 6), between(0, 4), between(-20, 24)], | ||
153 | #[between(-5, 6), between(3, 4), between(-20, 24)], | ||
154 | #[between(-5, 6), ZERO, ZERO], | ||
155 | #[between(0, 6), UNBOUNDED, UNBOUNDED], | ||
156 | #[between(0, 6), upTo(-2), upTo(0)], | ||
157 | #[between(0, 6), upTo(0), upTo(0)], | ||
158 | #[between(0, 6), upTo(3), upTo(18)], | ||
159 | #[between(0, 6), above(-2), above(-12)], | ||
160 | #[between(0, 6), above(0), above(0)], | ||
161 | #[between(0, 6), above(3), above(0)], | ||
162 | #[between(0, 6), between(-4, -3), between(-24, 0)], | ||
163 | #[between(0, 6), between(-4, 0), between(-24, 0)], | ||
164 | #[between(0, 6), between(-3, 4), between(-18, 24)], | ||
165 | #[between(0, 6), between(0, 4), between(0, 24)], | ||
166 | #[between(0, 6), between(3, 4), between(0, 24)], | ||
167 | #[between(0, 6), ZERO, ZERO], | ||
168 | #[between(5, 6), UNBOUNDED, UNBOUNDED], | ||
169 | #[between(5, 6), upTo(-2), upTo(-10)], | ||
170 | #[between(5, 6), upTo(0), upTo(0)], | ||
171 | #[between(5, 6), upTo(3), upTo(18)], | ||
172 | #[between(5, 6), above(-2), above(-12)], | ||
173 | #[between(5, 6), above(0), above(0)], | ||
174 | #[between(5, 6), above(3), above(15)], | ||
175 | #[between(5, 6), between(-4, -3), between(-24, -15)], | ||
176 | #[between(5, 6), between(-4, 0), between(-24, 0)], | ||
177 | #[between(5, 6), between(-3, 4), between(-18, 24)], | ||
178 | #[between(5, 6), between(0, 4), between(0, 24)], | ||
179 | #[between(5, 6), between(3, 4), between(15, 24)], | ||
180 | #[between(5, 6), ZERO, ZERO], | ||
181 | #[ZERO, UNBOUNDED, ZERO], | ||
182 | #[ZERO, upTo(-2), ZERO], | ||
183 | #[ZERO, upTo(0), ZERO], | ||
184 | #[ZERO, upTo(3), ZERO], | ||
185 | #[ZERO, above(-2), ZERO], | ||
186 | #[ZERO, above(0), ZERO], | ||
187 | #[ZERO, above(3), ZERO], | ||
188 | #[ZERO, between(-4, -3), ZERO], | ||
189 | #[ZERO, between(-4, 0), ZERO], | ||
190 | #[ZERO, between(-3, 4), ZERO], | ||
191 | #[ZERO, between(0, 4), ZERO], | ||
192 | #[ZERO, between(3, 4), ZERO], | ||
193 | #[ZERO, ZERO, ZERO] | ||
194 | ] | ||
195 | } | ||
196 | |||
197 | @Parameter(0) public var Interval a | ||
198 | @Parameter(1) public var Interval b | ||
199 | @Parameter(2) public var Interval result | ||
200 | |||
201 | @Test | ||
202 | def void multiplicatonTest() { | ||
203 | Assert.assertEquals(result, a * b) | ||
204 | } | ||
205 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/NegationTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/NegationTest.xtend new file mode 100644 index 00000000..477e925e --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/NegationTest.xtend | |||
@@ -0,0 +1,34 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
4 | import java.util.Collection | ||
5 | import org.junit.Assert | ||
6 | import org.junit.Test | ||
7 | import org.junit.runner.RunWith | ||
8 | import org.junit.runners.Parameterized | ||
9 | import org.junit.runners.Parameterized.Parameter | ||
10 | import org.junit.runners.Parameterized.Parameters | ||
11 | |||
12 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
13 | |||
14 | @RunWith(Parameterized) | ||
15 | class NegationTest { | ||
16 | @Parameters(name = "{index}: -{0} = {1}") | ||
17 | static def Collection<Object[]> data() { | ||
18 | #[ | ||
19 | #[EMPTY, EMPTY], | ||
20 | #[UNBOUNDED, UNBOUNDED], | ||
21 | #[upTo(1), above(-1)], | ||
22 | #[above(1), upTo(-1)], | ||
23 | #[between(2, 3), between(-3, -2)] | ||
24 | ] | ||
25 | } | ||
26 | |||
27 | @Parameter(0) public var Interval a | ||
28 | @Parameter(1) public var Interval result | ||
29 | |||
30 | @Test | ||
31 | def void negationTest() { | ||
32 | Assert.assertEquals(result, -a) | ||
33 | } | ||
34 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/PowerTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/PowerTest.xtend new file mode 100644 index 00000000..c842d90d --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/PowerTest.xtend | |||
@@ -0,0 +1,43 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
4 | import java.util.Collection | ||
5 | import org.junit.Assert | ||
6 | import org.junit.Test | ||
7 | import org.junit.runner.RunWith | ||
8 | import org.junit.runners.Parameterized | ||
9 | import org.junit.runners.Parameterized.Parameter | ||
10 | import org.junit.runners.Parameterized.Parameters | ||
11 | |||
12 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
13 | |||
14 | @RunWith(Parameterized) | ||
15 | class PowerTest { | ||
16 | @Parameters(name="{index}: {0} ** {1} = {2}") | ||
17 | static def Collection<Object[]> data() { | ||
18 | #[ | ||
19 | #[EMPTY, EMPTY, EMPTY], | ||
20 | #[EMPTY, between(-1, 1), EMPTY], | ||
21 | #[between(-1, 1), EMPTY, EMPTY], | ||
22 | #[upTo(-1), between(-1, 2), EMPTY], | ||
23 | #[upTo(0), between(-1, 2), between(0, 0)], | ||
24 | #[upTo(2), between(-1, 2), above(0)], | ||
25 | #[upTo(2), between(1, 2), between(0, 4)], | ||
26 | #[above(1), between(1, 2), above(1)], | ||
27 | #[between(2, 4), upTo(1), between(0, 4)], | ||
28 | #[between(0.25, 0.5), upTo(1), above(0.25)], | ||
29 | #[between(2, 3), above(1), above(2)], | ||
30 | #[between(0.25, 0.5), above(1), between(0, 0.5)], | ||
31 | #[between(1, 2), between(-1, 2), between(0.5, 4)] | ||
32 | ] | ||
33 | } | ||
34 | |||
35 | @Parameter(0) public var Interval a | ||
36 | @Parameter(1) public var Interval b | ||
37 | @Parameter(2) public var Interval result | ||
38 | |||
39 | @Test | ||
40 | def void powerTest() { | ||
41 | Assert.assertEquals(result, a ** b) | ||
42 | } | ||
43 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/RelationTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/RelationTest.xtend new file mode 100644 index 00000000..5527fbaa --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/RelationTest.xtend | |||
@@ -0,0 +1,126 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
4 | import java.util.Collection | ||
5 | import org.junit.Assert | ||
6 | import org.junit.Test | ||
7 | import org.junit.runner.RunWith | ||
8 | import org.junit.runners.Parameterized | ||
9 | import org.junit.runners.Parameterized.Parameter | ||
10 | import org.junit.runners.Parameterized.Parameters | ||
11 | |||
12 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
13 | |||
14 | @RunWith(Parameterized) | ||
15 | class RelationTest { | ||
16 | @Parameters(name = "{index}: {0} <> {1}") | ||
17 | static def Collection<Object[]> data() { | ||
18 | #[ | ||
19 | #[EMPTY, EMPTY, true, false, true, false, EMPTY], | ||
20 | #[EMPTY, between(1, 2), true, false, true, false, between(1, 2)], | ||
21 | #[between(1, 2), EMPTY, true, false, true, false, between(1, 2)], | ||
22 | #[upTo(1), upTo(0), false, true, false, true, upTo(1)], | ||
23 | #[upTo(1), upTo(1), false, true, false, true, upTo(1)], | ||
24 | #[upTo(1), upTo(2), false, true, false, true, upTo(2)], | ||
25 | #[upTo(1), above(0), false, true, false, true, UNBOUNDED], | ||
26 | #[upTo(1), above(1), false, true, false, true, UNBOUNDED], | ||
27 | #[upTo(1), above(2), false, false, true, true, UNBOUNDED], | ||
28 | #[upTo(1), between(-1, -1), false, true, false, true, upTo(1)], | ||
29 | #[upTo(1), between(-1, 0), false, true, false, true, upTo(1)], | ||
30 | #[upTo(1), between(-1, 1), false, true, false, true, upTo(1)], | ||
31 | #[upTo(1), between(-1, 2), false, true, false, true, upTo(2)], | ||
32 | #[upTo(1), between(1, 1), false, true, false, true, upTo(1)], | ||
33 | #[upTo(1), between(1, 2), false, true, false, true, upTo(2)], | ||
34 | #[upTo(1), between(2, 2), false, false, true, true, upTo(2)], | ||
35 | #[upTo(1), between(2, 3), false, false, true, true, upTo(3)], | ||
36 | #[above(1), upTo(0), false, false, false, false, UNBOUNDED], | ||
37 | #[above(1), upTo(1), false, true, false, false, UNBOUNDED], | ||
38 | #[above(1), upTo(2), false, true, false, true, UNBOUNDED], | ||
39 | #[above(1), above(0), false, true, false, true, above(0)], | ||
40 | #[above(1), above(1), false, true, false, true, above(1)], | ||
41 | #[above(1), above(2), false, true, false, true, above(1)], | ||
42 | #[above(1), between(-1, -1), false, false, false, false, above(-1)], | ||
43 | #[above(1), between(-1, 0), false, false, false, false, above(-1)], | ||
44 | #[above(1), between(-1, 1), false, true, false, false, above(-1)], | ||
45 | #[above(1), between(-1, 2), false, true, false, true, above(-1)], | ||
46 | #[above(1), between(1, 1), false, true, false, false, above(1)], | ||
47 | #[above(1), between(1, 2), false, true, false, true, above(1)], | ||
48 | #[above(1), between(2, 2), false, true, false, true, above(1)], | ||
49 | #[above(1), between(2, 3), false, true, false, true, above(1)], | ||
50 | #[between(1, 1), upTo(0), false, false, false, false, upTo(1)], | ||
51 | #[between(1, 1), upTo(1), false, true, false, false, upTo(1)], | ||
52 | #[between(1, 1), upTo(2), false, true, false, true, upTo(2)], | ||
53 | #[between(1, 1), above(0), false, true, false, true, above(0)], | ||
54 | #[between(1, 1), above(1), false, true, false, true, above(1)], | ||
55 | #[between(1, 1), above(2), false, false, true, true, above(1)], | ||
56 | #[between(1, 1), between(-1, -1), false, false, false, false, between(-1, 1)], | ||
57 | #[between(1, 1), between(-1, 0), false, false, false, false, between(-1, 1)], | ||
58 | #[between(1, 1), between(-1, 1), false, true, false, false, between(-1, 1)], | ||
59 | #[between(1, 1), between(-1, 2), false, true, false, true, between(-1, 2)], | ||
60 | #[between(1, 1), between(1, 1), true, true, false, false, between(1, 1)], | ||
61 | #[between(1, 1), between(1, 2), false, true, false, true, between(1, 2)], | ||
62 | #[between(1, 1), between(2, 2), false, false, true, true, between(1, 2)], | ||
63 | #[between(1, 1), between(2, 3), false, false, true, true, between(1, 3)], | ||
64 | #[between(-1, 1), upTo(-2), false, false, false, false, upTo(1)], | ||
65 | #[between(-1, 1), upTo(-1), false, true, false, false, upTo(1)], | ||
66 | #[between(-1, 1), upTo(0), false, true, false, true, upTo(1)], | ||
67 | #[between(-1, 1), upTo(1), false, true, false, true, upTo(1)], | ||
68 | #[between(-1, 1), upTo(2), false, true, false, true, upTo(2)], | ||
69 | #[between(-1, 1), above(-2), false, true, false, true, above(-2)], | ||
70 | #[between(-1, 1), above(-1), false, true, false, true, above(-1)], | ||
71 | #[between(-1, 1), above(0), false, true, false, true, above(-1)], | ||
72 | #[between(-1, 1), above(1), false, true, false, true, above(-1)], | ||
73 | #[between(-1, 1), above(2), false, false, true, true, above(-1)], | ||
74 | #[between(-1, 1), between(-3, -2), false, false, false, false, between(-3, 1)], | ||
75 | #[between(-1, 1), between(-2, -2), false, false, false, false, between(-2, 1)], | ||
76 | #[between(-1, 1), between(-2, -1), false, true, false, false, between(-2, 1)], | ||
77 | #[between(-1, 1), between(-2, 0), false, true, false, true, between(-2, 1)], | ||
78 | #[between(-1, 1), between(-2, 1), false, true, false, true, between(-2, 1)], | ||
79 | #[between(-1, 1), between(-2, 2), false, true, false, true, between(-2, 2)], | ||
80 | #[between(-1, 1), between(-1, -1), false, true, false, false, between(-1, 1)], | ||
81 | #[between(-1, 1), between(-1, 0), false, true, false, true, between(-1, 1)], | ||
82 | #[between(-1, 1), between(-1, 1), false, true, false, true, between(-1, 1)], | ||
83 | #[between(-1, 1), between(-1, 2), false, true, false, true, between(-1, 2)], | ||
84 | #[between(-1, 1), between(0, 0), false, true, false, true, between(-1, 1)], | ||
85 | #[between(-1, 1), between(0, 1), false, true, false, true, between(-1, 1)], | ||
86 | #[between(-1, 1), between(0, 2), false, true, false, true, between(-1, 2)], | ||
87 | #[between(-1, 1), between(1, 1), false, true, false, true, between(-1, 1)], | ||
88 | #[between(-1, 1), between(1, 2), false, true, false, true, between(-1, 2)], | ||
89 | #[between(-1, 1), between(2, 2), false, false, true, true, between(-1, 2)], | ||
90 | #[between(-1, 1), between(2, 3), false, false, true, true, between(-1, 3)] | ||
91 | ] | ||
92 | } | ||
93 | |||
94 | @Parameter(0) public var Interval a | ||
95 | @Parameter(1) public var Interval b | ||
96 | @Parameter(2) public var boolean mustEqual | ||
97 | @Parameter(3) public var boolean mayEqual | ||
98 | @Parameter(4) public var boolean mustBeLessThan | ||
99 | @Parameter(5) public var boolean mayBeLessThan | ||
100 | @Parameter(6) public var Interval join | ||
101 | |||
102 | @Test | ||
103 | def void mustEqualTest() { | ||
104 | Assert.assertEquals(mustEqual, a.mustEqual(b)) | ||
105 | } | ||
106 | |||
107 | @Test | ||
108 | def void mayEqualTest() { | ||
109 | Assert.assertEquals(mayEqual, a.mayEqual(b)) | ||
110 | } | ||
111 | |||
112 | @Test | ||
113 | def void mustBeLessThanTest() { | ||
114 | Assert.assertEquals(mustBeLessThan, a.mustBeLessThan(b)) | ||
115 | } | ||
116 | |||
117 | @Test | ||
118 | def void mayBeLessThanTest() { | ||
119 | Assert.assertEquals(mayBeLessThan, a.mayBeLessThan(b)) | ||
120 | } | ||
121 | |||
122 | @Test | ||
123 | def void joinTest() { | ||
124 | Assert.assertEquals(join, a.join(b)) | ||
125 | } | ||
126 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SubtractionTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SubtractionTest.xtend new file mode 100644 index 00000000..30709a9e --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SubtractionTest.xtend | |||
@@ -0,0 +1,49 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
4 | import java.util.Collection | ||
5 | import org.junit.Assert | ||
6 | import org.junit.Test | ||
7 | import org.junit.runner.RunWith | ||
8 | import org.junit.runners.Parameterized | ||
9 | import org.junit.runners.Parameterized.Parameter | ||
10 | import org.junit.runners.Parameterized.Parameters | ||
11 | |||
12 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
13 | |||
14 | @RunWith(Parameterized) | ||
15 | class SubtractionTest { | ||
16 | @Parameters(name = "{index}: {0} - {1} = {2}") | ||
17 | static def Collection<Object[]> data() { | ||
18 | #[ | ||
19 | #[EMPTY, EMPTY, EMPTY], | ||
20 | #[EMPTY, between(-1, 1), EMPTY], | ||
21 | #[between(-1, 1), EMPTY, EMPTY], | ||
22 | #[UNBOUNDED, UNBOUNDED, UNBOUNDED], | ||
23 | #[UNBOUNDED, upTo(2), UNBOUNDED], | ||
24 | #[UNBOUNDED, above(-2), UNBOUNDED], | ||
25 | #[UNBOUNDED, between(-1, 1), UNBOUNDED], | ||
26 | #[upTo(2), UNBOUNDED, UNBOUNDED], | ||
27 | #[upTo(2), upTo(1), UNBOUNDED], | ||
28 | #[upTo(2), above(-1), upTo(3)], | ||
29 | #[upTo(2), between(-1, 2), upTo(3)], | ||
30 | #[above(-2), UNBOUNDED, UNBOUNDED], | ||
31 | #[above(-2), upTo(1), above(-3)], | ||
32 | #[above(-2), above(-1), UNBOUNDED], | ||
33 | #[above(-2), between(-1, 2), above(-4)], | ||
34 | #[between(-2, 3), UNBOUNDED, UNBOUNDED], | ||
35 | #[between(-2, 3), upTo(1), above(-3)], | ||
36 | #[between(-2, 3), above(-1), upTo(4)], | ||
37 | #[between(-2, 3), between(-1, 2.5), between(-4.5, 4)] | ||
38 | ] | ||
39 | } | ||
40 | |||
41 | @Parameter(0) public var Interval a | ||
42 | @Parameter(1) public var Interval b | ||
43 | @Parameter(2) public var Interval result | ||
44 | |||
45 | @Test | ||
46 | def void subtractionTest() { | ||
47 | Assert.assertEquals(result, a - b) | ||
48 | } | ||
49 | } | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SumAggregatorTest.xtend b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SumAggregatorTest.xtend new file mode 100644 index 00000000..56172b6c --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/tests/interval/SumAggregatorTest.xtend | |||
@@ -0,0 +1,140 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.tests.interval | ||
2 | |||
3 | import com.google.common.collect.HashMultiset | ||
4 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationMode | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationOperator | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalRedBlackNode | ||
8 | import java.math.BigDecimal | ||
9 | import java.util.Random | ||
10 | import org.junit.Assert | ||
11 | import org.junit.Before | ||
12 | import org.junit.Test | ||
13 | |||
14 | import static hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval.* | ||
15 | |||
16 | class SumAggregatorTest { | ||
17 | val aggregator = new IntervalAggregationOperator(IntervalAggregationMode.SUM) | ||
18 | var IntervalRedBlackNode value = null | ||
19 | |||
20 | @Before | ||
21 | def void reset() { | ||
22 | value = aggregator.createNeutral | ||
23 | } | ||
24 | |||
25 | @Test | ||
26 | def void emptyTest() { | ||
27 | assertEquals(ZERO) | ||
28 | } | ||
29 | |||
30 | @Test | ||
31 | def void addSingleTest() { | ||
32 | add(between(-1, 1)) | ||
33 | assertEquals(between(-1, 1)) | ||
34 | } | ||
35 | |||
36 | @Test | ||
37 | def void addRemoveTest() { | ||
38 | add(between(-1, 1)) | ||
39 | remove(between(-1, 1)) | ||
40 | assertEquals(ZERO) | ||
41 | } | ||
42 | |||
43 | @Test | ||
44 | def void addTwoTest() { | ||
45 | add(between(-1, 1)) | ||
46 | add(above(2)) | ||
47 | assertEquals(above(1)) | ||
48 | } | ||
49 | |||
50 | @Test | ||
51 | def void addTwoRemoveFirstTest() { | ||
52 | add(between(-1, 1)) | ||
53 | add(above(2)) | ||
54 | remove(between(-1, 1)) | ||
55 | assertEquals(above(2)) | ||
56 | } | ||
57 | |||
58 | @Test | ||
59 | def void addTwoRemoveSecondTest() { | ||
60 | add(between(-1, 1)) | ||
61 | add(above(2)) | ||
62 | remove(above(2)) | ||
63 | assertEquals(between(-1, 1)) | ||
64 | } | ||
65 | |||
66 | @Test | ||
67 | def void addMultiplicityTest() { | ||
68 | add(between(-1, 1)) | ||
69 | add(between(-1, 1)) | ||
70 | add(between(-1, 1)) | ||
71 | assertEquals(between(-3, 3)) | ||
72 | } | ||
73 | |||
74 | @Test | ||
75 | def void removeAllMultiplicityTest() { | ||
76 | add(between(-1, 1)) | ||
77 | add(between(-1, 1)) | ||
78 | add(between(-1, 1)) | ||
79 | remove(between(-1, 1)) | ||
80 | remove(between(-1, 1)) | ||
81 | remove(between(-1, 1)) | ||
82 | assertEquals(ZERO) | ||
83 | } | ||
84 | |||
85 | @Test | ||
86 | def void removeSomeMultiplicityTest() { | ||
87 | add(between(-1, 1)) | ||
88 | add(between(-1, 1)) | ||
89 | add(between(-1, 1)) | ||
90 | remove(between(-1, 1)) | ||
91 | remove(between(-1, 1)) | ||
92 | assertEquals(between(-1, 1)) | ||
93 | } | ||
94 | |||
95 | @Test | ||
96 | def void largeTest() { | ||
97 | val starts = #[null, new BigDecimal(-3), new BigDecimal(-2), new BigDecimal(-1)] | ||
98 | val ends = #[new BigDecimal(1), new BigDecimal(2), new BigDecimal(3), null] | ||
99 | val current = HashMultiset.create | ||
100 | val random = new Random(1) | ||
101 | for (var int i = 0; i < 1000; i++) { | ||
102 | val start = starts.get(random.nextInt(starts.size)) | ||
103 | val end = ends.get(random.nextInt(ends.size)) | ||
104 | val interval = Interval.of(start, end) | ||
105 | val isInsert = !current.contains(interval) || random.nextInt(3) == 0 | ||
106 | if (isInsert) { | ||
107 | current.add(interval) | ||
108 | } else { | ||
109 | current.remove(interval) | ||
110 | } | ||
111 | val expected = current.stream.reduce(aggregator.mode).orElse(ZERO) | ||
112 | update(interval, isInsert) | ||
113 | assertEquals(expected) | ||
114 | } | ||
115 | } | ||
116 | |||
117 | private def update(Interval interval, boolean isInsert) { | ||
118 | value = aggregator.update(value, interval, isInsert) | ||
119 | val nodes = newArrayList | ||
120 | var node = value.min | ||
121 | while (node !== null) { | ||
122 | nodes += node | ||
123 | node = node.successor | ||
124 | } | ||
125 | value.assertSubtreeIsValid | ||
126 | } | ||
127 | |||
128 | private def add(Interval interval) { | ||
129 | update(interval, true) | ||
130 | } | ||
131 | |||
132 | private def remove(Interval interval) { | ||
133 | update(interval, false) | ||
134 | } | ||
135 | |||
136 | private def assertEquals(Interval interval) { | ||
137 | val actual = aggregator.getAggregate(value) | ||
138 | Assert.assertEquals(interval, actual) | ||
139 | } | ||
140 | } | ||