feat: add cardinality interval abstraction

4 files changed, 139 insertions, 2 deletions

diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
index a7e09023..d18187e5 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.query.viatra.tests;
+package tools.refinery.store.query.viatra;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.representation.Relation;
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
index 117edd3e..e8fa6ed1 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.query.viatra.tests;
+package tools.refinery.store.query.viatra;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.representation.Relation;
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/cardinality/UpperCardinalitySumAggregationOperatorStreamTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/cardinality/UpperCardinalitySumAggregationOperatorStreamTest.java
new file mode 100644
index 00000000..07869050
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/cardinality/UpperCardinalitySumAggregationOperatorStreamTest.java
@@ -0,0 +1,50 @@
+package tools.refinery.store.query.viatra.internal.cardinality;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import tools.refinery.store.model.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.model.representation.cardinality.UpperCardinality;
+
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+class UpperCardinalitySumAggregationOperatorStreamTest {
+        @ParameterizedTest
+        @MethodSource
+        void testStream(Stream<UpperCardinality> stream, UpperCardinality expected) {
+                var result = UpperCardinalitySumAggregationOperator.INSTANCE.aggregateStream(stream);
+                assertThat(result, equalTo(expected));
+        }
+
+        static Stream<Arguments> testStream() {
+                return Stream.of(
+                                Arguments.of(Stream.of(), UpperCardinalities.ZERO),
+                                Arguments.of(Stream.of(UpperCardinality.of(3)), UpperCardinality.of(3)),
+                                Arguments.of(
+                                                Stream.of(
+                                                                UpperCardinality.of(2),
+                                                                UpperCardinality.of(3)
+                                                ),
+                                                UpperCardinality.of(5)
+                                ),
+                                Arguments.of(Stream.of(UpperCardinalities.UNBOUNDED), UpperCardinalities.UNBOUNDED),
+                                Arguments.of(
+                                                Stream.of(
+                                                                UpperCardinalities.UNBOUNDED,
+                                                                UpperCardinalities.UNBOUNDED
+                                                ),
+                                                UpperCardinalities.UNBOUNDED
+                                ),
+                                Arguments.of(
+                                                Stream.of(
+                                                                UpperCardinalities.UNBOUNDED,
+                                                                UpperCardinality.of(3)
+                                                ),
+                                                UpperCardinalities.UNBOUNDED
+                                )
+                );
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/cardinality/UpperCardinalitySumAggregationOperatorTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/cardinality/UpperCardinalitySumAggregationOperatorTest.java
new file mode 100644
index 00000000..afc4a2f3
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/cardinality/UpperCardinalitySumAggregationOperatorTest.java
@@ -0,0 +1,87 @@
+package tools.refinery.store.query.viatra.internal.cardinality;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.model.representation.cardinality.UpperCardinality;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+class UpperCardinalitySumAggregationOperatorTest {
+        private UpperCardinalitySumAggregationOperator.Accumulator accumulator;
+
+        @BeforeEach
+        void beforeEach() {
+                accumulator = UpperCardinalitySumAggregationOperator.INSTANCE.createNeutral();
+        }
+
+        @Test
+        void emptyAggregationTest() {
+                assertResult(UpperCardinality.of(0));
+        }
+
+        @Test
+        void singleBoundedTest() {
+                insert(UpperCardinality.of(3));
+                assertResult(UpperCardinality.of(3));
+        }
+
+        @Test
+        void multipleBoundedTest() {
+                insert(UpperCardinality.of(2));
+                insert(UpperCardinality.of(3));
+                assertResult(UpperCardinality.of(5));
+        }
+
+        @Test
+        void singleUnboundedTest() {
+                insert(UpperCardinalities.UNBOUNDED);
+                assertResult(UpperCardinalities.UNBOUNDED);
+        }
+
+        @Test
+        void multipleUnboundedTest() {
+                insert(UpperCardinalities.UNBOUNDED);
+                insert(UpperCardinalities.UNBOUNDED);
+                assertResult(UpperCardinalities.UNBOUNDED);
+        }
+
+        @Test
+        void removeBoundedTest() {
+                insert(UpperCardinality.of(2));
+                insert(UpperCardinality.of(3));
+                remove(UpperCardinality.of(2));
+                assertResult(UpperCardinality.of(3));
+        }
+
+        @Test
+        void removeAllUnboundedTest() {
+                insert(UpperCardinalities.UNBOUNDED);
+                insert(UpperCardinality.of(3));
+                remove(UpperCardinalities.UNBOUNDED);
+                assertResult(UpperCardinality.of(3));
+        }
+
+        @Test
+        void removeSomeUnboundedTest() {
+                insert(UpperCardinalities.UNBOUNDED);
+                insert(UpperCardinalities.UNBOUNDED);
+                insert(UpperCardinality.of(3));
+                remove(UpperCardinalities.UNBOUNDED);
+                assertResult(UpperCardinalities.UNBOUNDED);
+        }
+
+        private void insert(UpperCardinality value) {
+                accumulator = UpperCardinalitySumAggregationOperator.INSTANCE.update(accumulator, value, true);
+        }
+
+        private void remove(UpperCardinality value) {
+                accumulator = UpperCardinalitySumAggregationOperator.INSTANCE.update(accumulator, value, false);
+        }
+
+        private void assertResult(UpperCardinality expected) {
+                var result = UpperCardinalitySumAggregationOperator.INSTANCE.getAggregate(accumulator);
+                assertThat(result, equalTo(expected));
+        }
+}