From d91acf3690682d243dbc150df902525b6e545c2f Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Mon, 23 Jan 2023 20:27:55 +0100 Subject: refactor: Model store and query API Use Adapters to simplify API usage. --- .../refinery/store/map/tests/MapUnitTests.java | 9 +- .../store/model/hashTests/HashEfficiencyTest.java | 161 ----------------- .../store/model/hashtests/HashEfficiencyTest.java | 161 +++++++++++++++++ .../cardinality/CardinalityIntervalTest.java | 122 ------------- .../cardinality/CardinalityIntervalsTest.java | 21 --- .../cardinality/EmptyCardinalityIntervalTest.java | 14 -- .../cardinality/FiniteCardinalityIntervalTest.java | 20 --- .../cardinality/FiniteUpperCardinalityTest.java | 12 -- .../cardinality/UpperCardinalitiesTest.java | 25 --- .../cardinality/UpperCardinalityTest.java | 110 ------------ .../refinery/store/model/tests/ModelTest.java | 190 +++++++++++---------- .../cardinality/CardinalityIntervalTest.java | 123 +++++++++++++ .../cardinality/CardinalityIntervalsTest.java | 23 +++ .../cardinality/EmptyCardinalityIntervalTest.java | 15 ++ .../cardinality/FiniteCardinalityIntervalTest.java | 23 +++ .../cardinality/FiniteUpperCardinalityTest.java | 13 ++ .../cardinality/UpperCardinalitiesTest.java | 28 +++ .../cardinality/UpperCardinalityTest.java | 112 ++++++++++++ 18 files changed, 599 insertions(+), 583 deletions(-) delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/hashTests/HashEfficiencyTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/hashtests/HashEfficiencyTest.java delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalTest.java delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalsTest.java delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityIntervalTest.java delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteCardinalityIntervalTest.java delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinalityTest.java delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalitiesTest.java delete mode 100644 subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalityTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalsTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/EmptyCardinalityIntervalTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteCardinalityIntervalTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinalityTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalitiesTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalityTest.java (limited to 'subprojects/store/src/test') diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java index 081112cc..77c62305 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java @@ -1,18 +1,17 @@ package tools.refinery.store.map.tests; -import static org.junit.jupiter.api.Assertions.assertEquals; - import org.junit.jupiter.api.Test; - import tools.refinery.store.map.VersionedMapStore; import tools.refinery.store.map.VersionedMapStoreImpl; -import tools.refinery.store.tuple.Tuple; import tools.refinery.store.model.TupleHashProvider; +import tools.refinery.store.tuple.Tuple; + +import static org.junit.jupiter.api.Assertions.assertEquals; class MapUnitTests { @Test void defaultTest() { - VersionedMapStore store = new VersionedMapStoreImpl(TupleHashProvider.singleton(), false); + VersionedMapStore store = new VersionedMapStoreImpl<>(TupleHashProvider.INSTANCE, false); var map = store.createMap(); var out1 = map.put(Tuple.of(0), true); assertEquals(false, out1); diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/hashTests/HashEfficiencyTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/hashTests/HashEfficiencyTest.java deleted file mode 100644 index ceec40f5..00000000 --- a/subprojects/store/src/test/java/tools/refinery/store/model/hashTests/HashEfficiencyTest.java +++ /dev/null @@ -1,161 +0,0 @@ -package tools.refinery.store.model.hashTests; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.ArrayList; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; - -import org.junit.jupiter.api.Test; - -import tools.refinery.store.map.ContinousHashProvider; -import tools.refinery.store.tuple.Tuple; -import tools.refinery.store.model.TupleHashProvider; -import tools.refinery.store.model.TupleHashProviderBitMagic; - -class HashEfficiencyTest { - - private static List permutations(int range, int arity) { - if(arity == 1) { - List result = new ArrayList<>(range); - for(int i=0; i 1) { - List smallers = permutations(range, arity-1); - List result = new ArrayList<>(range*smallers.size()); - for(Tuple smaller : smallers) { - for(int i=0; i nPermutations(int arity, int n) { - int range = amountToRange(arity, n); - List permutations = permutations(range, arity); - return permutations.subList(0, n); - } - - public static List nRandoms(int arity, int n, int seed) { - int range = amountToRange(arity, n); - List permutations = new ArrayList<>(n); - Random r = new Random(seed); - for(int i = 0; i p = permutations(10, 2); - assertEquals(p.size(),10*10); - } -// private void printTuples(List p) { -// for(Tuple element : p) { -// System.out.println(element); -// } -// } - @Test - void nPermutationTest() { - final int amount = 500; - List p = nPermutations(2, amount); - assertEquals(amount,p.size()); - } - @Test - void nRandomTest() { - final int amount = 500; - List p = nRandoms(2, amount, 1);; - assertEquals(amount,p.size()); - } - private static double calculateHashClashes(List tuples, ContinousHashProvider chp) { - int sumClashes = 0; - - for(int i = 0; i chp, Tuple a, Tuple b) { - if(a.equals(b)) return 0; - final int bits = 5; - final int segments = Integer.SIZE/bits; - final int mask = (1<>(depth*5))&mask; - int bHash = (chp.getHash(b, index)>>(depth*5))&mask; - if(aHash != bHash) { - return i+1; - } - if(i>400) { - throw new IllegalStateException(a+" vs "+b); - } - } - } - private static double caclulateOptimalHashClash(int size) { - return (Math.log(size)/Math.log(32)); - } - public static void main(String[] args) { - List hashNames = new LinkedList<>(); - List> hashes = new LinkedList<>(); - hashNames.add("PrimeGroup"); - hashes.add(new TupleHashProvider()); - hashNames.add("BitMagic"); - hashes.add(new TupleHashProviderBitMagic()); - - int[] arities = new int[] {2,3,4,5}; - int[] sizes = new int[] {32*32,32*32*8}; - - System.out.println("Size,Arity,DataSource,Hash,Chashes,Optimal,Badness"); - for(int size : sizes) { - double optimalClashes = caclulateOptimalHashClash(size); - for(int arity : arities) { - List dataSourceNames = new LinkedList<>(); - List> dataSources = new LinkedList<>(); - -// dataSourceNames.add("Permutation"); -// dataSources.add(nPermutations(arity, size)); - dataSourceNames.add("Random"); - dataSources.add(nRandoms(arity, size, 0)); - - for(int dataSourceIndex = 0; dataSourceIndex permutations(int range, int arity) { + if(arity == 1) { + List result = new ArrayList<>(range); + for(int i=0; i 1) { + List smallers = permutations(range, arity-1); + List result = new ArrayList<>(range*smallers.size()); + for(Tuple smaller : smallers) { + for(int i=0; i nPermutations(int arity, int n) { + int range = amountToRange(arity, n); + List permutations = permutations(range, arity); + return permutations.subList(0, n); + } + + public static List nRandoms(int arity, int n, int seed) { + int range = amountToRange(arity, n); + List permutations = new ArrayList<>(n); + Random r = new Random(seed); + for(int i = 0; i p = permutations(10, 2); + assertEquals(p.size(),10*10); + } +// private void printTuples(List p) { +// for(Tuple element : p) { +// System.out.println(element); +// } +// } + @Test + void nPermutationTest() { + final int amount = 500; + List p = nPermutations(2, amount); + assertEquals(amount,p.size()); + } + @Test + void nRandomTest() { + final int amount = 500; + List p = nRandoms(2, amount, 1);; + assertEquals(amount,p.size()); + } + private static double calculateHashClashes(List tuples, ContinousHashProvider chp) { + int sumClashes = 0; + + for(int i = 0; i chp, Tuple a, Tuple b) { + if(a.equals(b)) return 0; + final int bits = 5; + final int segments = Integer.SIZE/bits; + final int mask = (1<>(depth*5))&mask; + int bHash = (chp.getHash(b, index)>>(depth*5))&mask; + if(aHash != bHash) { + return i+1; + } + if(i>400) { + throw new IllegalStateException(a+" vs "+b); + } + } + } + private static double caclulateOptimalHashClash(int size) { + return (Math.log(size)/Math.log(32)); + } + public static void main(String[] args) { + List hashNames = new LinkedList<>(); + List> hashes = new LinkedList<>(); + hashNames.add("PrimeGroup"); + hashes.add(new TupleHashProvider()); + hashNames.add("BitMagic"); + hashes.add(new TupleHashProviderBitMagic()); + + int[] arities = new int[] {2,3,4,5}; + int[] sizes = new int[] {32*32,32*32*8}; + + System.out.println("Size,Arity,DataSource,Hash,Chashes,Optimal,Badness"); + for(int size : sizes) { + double optimalClashes = caclulateOptimalHashClash(size); + for(int arity : arities) { + List dataSourceNames = new LinkedList<>(); + List> dataSources = new LinkedList<>(); + +// dataSourceNames.add("Permutation"); +// dataSources.add(nPermutations(arity, size)); + dataSourceNames.add("Random"); + dataSources.add(nRandoms(arity, size, 0)); + + for(int dataSourceIndex = 0; dataSourceIndex minTest() { - return Stream.of( - Arguments.of(atMost(1), atMost(1), atMost(1)), - Arguments.of(atMost(1), between(2, 3), atMost(1)), - Arguments.of(atMost(1), atLeast(2), atMost(1)), - Arguments.of(atMost(1), ERROR, ERROR), - Arguments.of(atLeast(1), atLeast(2), atLeast(1)), - Arguments.of(atLeast(1), ERROR, ERROR), - Arguments.of(ERROR, atLeast(2), ERROR), - Arguments.of(ERROR, ERROR, ERROR) - ); - } - - @ParameterizedTest(name = "max({0}, {1}) == {2}") - @MethodSource - void maxTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { - assertThat(a.max(b), equalTo(expected)); - } - - static Stream maxTest() { - return Stream.of( - Arguments.of(atMost(1), atMost(1), atMost(1)), - Arguments.of(atMost(1), between(2, 3), between(2, 3)), - Arguments.of(atMost(1), atLeast(2), atLeast(2)), - Arguments.of(atMost(1), ERROR, ERROR), - Arguments.of(atLeast(1), atLeast(2), atLeast(2)), - Arguments.of(atLeast(1), ERROR, ERROR), - Arguments.of(ERROR, atLeast(2), ERROR), - Arguments.of(ERROR, ERROR, ERROR) - ); - } - - @ParameterizedTest(name = "{0} + {1} == {2}") - @MethodSource - void addTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { - assertThat(a.add(b), equalTo(expected)); - } - - static Stream addTest() { - return Stream.of( - Arguments.of(atMost(1), atMost(1), atMost(2)), - Arguments.of(atMost(1), between(2, 3), between(2, 4)), - Arguments.of(atMost(1), atLeast(2), atLeast(2)), - Arguments.of(atMost(1), ERROR, ERROR), - Arguments.of(atLeast(1), atLeast(2), atLeast(3)), - Arguments.of(atLeast(1), ERROR, ERROR), - Arguments.of(ERROR, atLeast(2), ERROR), - Arguments.of(ERROR, ERROR, ERROR) - ); - } - - @ParameterizedTest(name = "{0} * {1} == {2}") - @MethodSource - void multiplyTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { - assertThat(a.multiply(b), equalTo(expected)); - } - - static Stream multiplyTest() { - return Stream.of( - Arguments.of(between(2, 3), between(4, 5), between(8, 15)), - Arguments.of(atLeast(2), between(4, 5), atLeast(8)), - Arguments.of(between(2, 3), atLeast(4), atLeast(8)), - Arguments.of(between(2, 3), ERROR, ERROR), - Arguments.of(ERROR, between(4, 5), ERROR), - Arguments.of(ERROR, ERROR, ERROR) - ); - } - - @ParameterizedTest(name = "{0} /\\ {1} == {2}") - @MethodSource - void meetTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { - assertThat(a.meet(b), equalTo(expected)); - } - - static Stream meetTest() { - return Stream.of( - Arguments.of(atMost(1), atMost(2), atMost(1)), - Arguments.of(atMost(2), between(1, 3), between(1, 2)), - Arguments.of(atMost(1), between(1, 3), exactly(1)), - Arguments.of(atMost(1), between(2, 3), ERROR), - Arguments.of(atMost(1), ERROR, ERROR), - Arguments.of(ERROR, atMost(1), ERROR), - Arguments.of(ERROR, ERROR, ERROR) - ); - } - - @ParameterizedTest(name = "{0} \\/ {1} == {2}") - @MethodSource - void joinTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { - assertThat(a.join(b), equalTo(expected)); - } - - static Stream joinTest() { - return Stream.of( - Arguments.of(atMost(1), atMost(2), atMost(2)), - Arguments.of(atMost(2), between(1, 3), atMost(3)), - Arguments.of(atMost(1), between(2, 3), atMost(3)), - Arguments.of(atMost(1), ERROR, atMost(1)), - Arguments.of(ERROR, atMost(1), atMost(1)), - Arguments.of(ERROR, ERROR, ERROR) - ); - } -} diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalsTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalsTest.java deleted file mode 100644 index ef68a607..00000000 --- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalsTest.java +++ /dev/null @@ -1,21 +0,0 @@ -package tools.refinery.store.model.representation.cardinality; - -import org.junit.jupiter.api.Test; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.*; - -class CardinalityIntervalsTest { - @Test - void betweenEmptyTest() { - var interval = CardinalityIntervals.between(2, 1); - assertThat(interval.isEmpty(), equalTo(true)); - } - - @Test - void betweenNegativeUpperBoundTest() { - var interval = CardinalityIntervals.between(0, -1); - assertThat(interval.upperBound(), equalTo(UpperCardinalities.UNBOUNDED)); - assertThat(interval.isEmpty(), equalTo(false)); - } -} diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityIntervalTest.java deleted file mode 100644 index 41c884ec..00000000 --- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityIntervalTest.java +++ /dev/null @@ -1,14 +0,0 @@ -package tools.refinery.store.model.representation.cardinality; - -import org.junit.jupiter.api.Test; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.lessThan; - -class EmptyCardinalityIntervalTest { - @Test - void inconsistentBoundsTest() { - assertThat(CardinalityIntervals.ERROR.upperBound().compareToInt(CardinalityIntervals.ERROR.lowerBound()), - lessThan(0)); - } -} diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteCardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteCardinalityIntervalTest.java deleted file mode 100644 index dfb37786..00000000 --- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteCardinalityIntervalTest.java +++ /dev/null @@ -1,20 +0,0 @@ -package tools.refinery.store.model.representation.cardinality; - -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.assertThrows; - -class FiniteCardinalityIntervalTest { - @Test - void invalidLowerBoundConstructorTest() { - assertThrows(IllegalArgumentException.class, () -> new NonEmptyCardinalityInterval(-1, - UpperCardinalities.UNBOUNDED)); - } - - @Test - void invalidUpperBoundConstructorTest() { - var upperCardinality = UpperCardinality.of(1); - assertThrows(IllegalArgumentException.class, () -> new NonEmptyCardinalityInterval(2, - upperCardinality)); - } -} diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinalityTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinalityTest.java deleted file mode 100644 index 3f0f7a4a..00000000 --- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinalityTest.java +++ /dev/null @@ -1,12 +0,0 @@ -package tools.refinery.store.model.representation.cardinality; - -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.assertThrows; - -class FiniteUpperCardinalityTest { - @Test - void invalidConstructorTest() { - assertThrows(IllegalArgumentException.class, () -> new FiniteUpperCardinality(-1)); - } -} diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalitiesTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalitiesTest.java deleted file mode 100644 index 13171ae5..00000000 --- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalitiesTest.java +++ /dev/null @@ -1,25 +0,0 @@ -package tools.refinery.store.model.representation.cardinality; - -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.instanceOf; - -class UpperCardinalitiesTest { - @ParameterizedTest - @ValueSource(ints = {0, 1, 255, 256, 1000, Integer.MAX_VALUE}) - void valueOfBoundedTest(int value) { - var upperCardinality = UpperCardinalities.valueOf(value); - assertThat(upperCardinality, instanceOf(FiniteUpperCardinality.class)); - assertThat(((FiniteUpperCardinality) upperCardinality).finiteUpperBound(), equalTo(value)); - } - - @Test - void valueOfUnboundedTest() { - var upperCardinality = UpperCardinalities.valueOf(-1); - assertThat(upperCardinality, instanceOf(UnboundedUpperCardinality.class)); - } -} diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalityTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalityTest.java deleted file mode 100644 index f5763c2d..00000000 --- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalityTest.java +++ /dev/null @@ -1,110 +0,0 @@ -package tools.refinery.store.model.representation.cardinality; - -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; - -import java.util.stream.Stream; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.equalTo; - -class UpperCardinalityTest { - @ParameterizedTest(name = "min({0}, {1}) == {2}") - @MethodSource - void minTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { - assertThat(a.min(b), equalTo(expected)); - } - - static Stream minTest() { - return Stream.of( - Arguments.of(UpperCardinality.of(0), UpperCardinality.of(0), UpperCardinality.of(0)), - Arguments.of(UpperCardinality.of(0), UpperCardinality.of(1), UpperCardinality.of(0)), - Arguments.of(UpperCardinality.of(1), UpperCardinality.of(0), UpperCardinality.of(0)), - Arguments.of(UpperCardinality.of(0), UpperCardinalities.UNBOUNDED, UpperCardinality.of(0)), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(0), UpperCardinality.of(0)), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) - ); - } - - @ParameterizedTest(name = "max({0}, {1}) == {2}") - @MethodSource - void maxTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { - assertThat(a.max(b), equalTo(expected)); - } - - static Stream maxTest() { - return Stream.of( - Arguments.of(UpperCardinality.of(0), UpperCardinality.of(0), UpperCardinality.of(0)), - Arguments.of(UpperCardinality.of(0), UpperCardinality.of(1), UpperCardinality.of(1)), - Arguments.of(UpperCardinality.of(1), UpperCardinality.of(0), UpperCardinality.of(1)), - Arguments.of(UpperCardinality.of(0), UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(0), UpperCardinalities.UNBOUNDED), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) - ); - } - - @ParameterizedTest(name = "{0} + {1} == {2}") - @MethodSource - void addTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { - assertThat(a.add(b), equalTo(expected)); - } - - static Stream addTest() { - return Stream.of( - Arguments.of(UpperCardinality.of(2), UpperCardinality.of(3), UpperCardinality.of(5)), - Arguments.of(UpperCardinality.of(2), UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(2), UpperCardinalities.UNBOUNDED), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) - ); - } - - @ParameterizedTest(name = "{0} * {1} == {2}") - @MethodSource - void multiplyTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { - assertThat(a.multiply(b), equalTo(expected)); - } - - static Stream multiplyTest() { - return Stream.of( - Arguments.of(UpperCardinality.of(2), UpperCardinality.of(3), UpperCardinality.of(6)), - Arguments.of(UpperCardinality.of(2), UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(2), UpperCardinalities.UNBOUNDED), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) - ); - } - - @ParameterizedTest(name = "{0}.compareTo({1}) == {2}") - @MethodSource - void compareToTest(UpperCardinality a, UpperCardinality b, int expected) { - assertThat(a.compareTo(b), equalTo(expected)); - } - - static Stream compareToTest() { - return Stream.of( - Arguments.of(UpperCardinality.of(0), UpperCardinality.of(0), 0), - Arguments.of(UpperCardinality.of(0), UpperCardinality.of(1), -1), - Arguments.of(UpperCardinality.of(1), UpperCardinality.of(0), 1), - Arguments.of(UpperCardinality.of(0), UpperCardinalities.UNBOUNDED, -1), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(0), 1), - Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, 0) - ); - } - - @ParameterizedTest(name = "{0}.compareToInt({1}) == {2}") - @MethodSource - void compareToIntTest(UpperCardinality a, int b, int expected) { - assertThat(a.compareToInt(b), equalTo(expected)); - } - - static Stream compareToIntTest() { - return Stream.of( - Arguments.of(UpperCardinality.of(3), -1, 1), - Arguments.of(UpperCardinality.of(3), 2, 1), - Arguments.of(UpperCardinality.of(3), 3, 0), - Arguments.of(UpperCardinality.of(3), 4, -1), - Arguments.of(UpperCardinalities.UNBOUNDED, -1, 1), - Arguments.of(UpperCardinalities.UNBOUNDED, 3, 1) - ); - } -} diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java index 7a89daeb..e7bff1f9 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java @@ -1,145 +1,149 @@ package tools.refinery.store.model.tests; import org.junit.jupiter.api.Test; -import tools.refinery.store.model.Model; import tools.refinery.store.model.ModelStore; -import tools.refinery.store.model.ModelStoreImpl; -import tools.refinery.store.model.representation.Relation; +import tools.refinery.store.representation.Symbol; import tools.refinery.store.tuple.Tuple; -import java.util.Set; - import static org.junit.jupiter.api.Assertions.*; class ModelTest { - @Test void modelConstructionTest() { - Relation person = new Relation<>("Person", 1, Boolean.class, false); - Relation friend = new Relation<>("friend", 2, Boolean.class, false); + var person = new Symbol<>("Person", 1, Boolean.class, false); + var friend = new Symbol<>("friend", 2, Boolean.class, false); - ModelStore store = new ModelStoreImpl(Set.of(person, friend)); - Model model = store.createModel(); + var store = ModelStore.builder().symbols(person, friend).build(); + var symbols = store.getSymbols(); - assertTrue(store.getDataRepresentations().contains(person)); - assertTrue(store.getDataRepresentations().contains(friend)); - assertTrue(model.getDataRepresentations().contains(person)); - assertTrue(model.getDataRepresentations().contains(friend)); + assertTrue(symbols.contains(person)); + assertTrue(symbols.contains(friend)); - Relation other = new Relation("other", 2, Integer.class, null); - assertFalse(model.getDataRepresentations().contains(other)); + var other = new Symbol<>("other", 2, Integer.class, null); + assertFalse(symbols.contains(other)); } @Test void modelBuildingTest() { - Relation person = new Relation<>("Person", 1, Boolean.class, false); - Relation age = new Relation("age", 1, Integer.class, null); - Relation friend = new Relation<>("friend", 2, Boolean.class, false); - - ModelStore store = new ModelStoreImpl(Set.of(person, age, friend)); - Model model = store.createModel(); - - model.put(person, Tuple.of(0), true); - model.put(person, Tuple.of(1), true); - model.put(age, Tuple.of(0), 3); - model.put(age, Tuple.of(1), 1); - model.put(friend, Tuple.of(0, 1), true); - model.put(friend, Tuple.of(1, 0), true); - - assertTrue(model.get(person, Tuple.of(0))); - assertTrue(model.get(person, Tuple.of(1))); - assertFalse(model.get(person, Tuple.of(2))); - - assertEquals(3, model.get(age, Tuple.of(0))); - assertEquals(1, model.get(age, Tuple.of(1))); - assertNull(model.get(age, Tuple.of(2))); - - assertTrue(model.get(friend, Tuple.of(0, 1))); - assertFalse(model.get(friend, Tuple.of(0, 5))); + var person = new Symbol<>("Person", 1, Boolean.class, false); + var age = new Symbol<>("age", 1, Integer.class, null); + var friend = new Symbol<>("friend", 2, Boolean.class, false); + + var store = ModelStore.builder().symbols(person, age, friend).build(); + var model = store.createModel(); + var personInterpretation = model.getInterpretation(person); + var ageInterpretation = model.getInterpretation(age); + var friendInterpretation = model.getInterpretation(friend); + + personInterpretation.put(Tuple.of(0), true); + personInterpretation.put(Tuple.of(1), true); + ageInterpretation.put(Tuple.of(0), 3); + ageInterpretation.put(Tuple.of(1), 1); + friendInterpretation.put(Tuple.of(0, 1), true); + friendInterpretation.put(Tuple.of(1, 0), true); + + assertTrue(personInterpretation.get(Tuple.of(0))); + assertTrue(personInterpretation.get(Tuple.of(1))); + assertFalse(personInterpretation.get(Tuple.of(2))); + + assertEquals(3, ageInterpretation.get(Tuple.of(0))); + assertEquals(1, ageInterpretation.get(Tuple.of(1))); + assertNull(ageInterpretation.get( Tuple.of(2))); + + assertTrue(friendInterpretation.get(Tuple.of(0, 1))); + assertFalse(friendInterpretation.get(Tuple.of(0, 5))); } @Test void modelBuildingArityFailTest() { - Relation person = new Relation<>("Person", 1, Boolean.class, false); + var person = new Symbol<>("Person", 1, Boolean.class, false); - ModelStore store = new ModelStoreImpl(Set.of(person)); - Model model = store.createModel(); + var store = ModelStore.builder().symbols(person).build(); + var model = store.createModel(); + var personInterpretation = model.getInterpretation(person); final Tuple tuple3 = Tuple.of(1, 1, 1); - assertThrows(IllegalArgumentException.class, () -> model.put(person, tuple3, true)); - assertThrows(IllegalArgumentException.class, () -> model.get(person, tuple3)); + assertThrows(IllegalArgumentException.class, () -> personInterpretation.put(tuple3, true)); + assertThrows(IllegalArgumentException.class, () -> personInterpretation.get(tuple3)); } @Test void modelBuildingNullFailTest() { - Relation age = new Relation("age", 1, Integer.class, null); - ModelStore store = new ModelStoreImpl(Set.of(age)); - Model model = store.createModel(); + var age = new Symbol<>("age", 1, Integer.class, null); + + var store = ModelStore.builder().symbols(age).build(); + var model = store.createModel(); + var ageInterpretation = model.getInterpretation(age); - model.put(age, Tuple.of(1), null); // valid - assertThrows(IllegalArgumentException.class, () -> model.put(age, null, 1)); - assertThrows(IllegalArgumentException.class, () -> model.get(age, null)); + ageInterpretation.put(Tuple.of(1), null); // valid + assertThrows(IllegalArgumentException.class, () -> ageInterpretation.put(null, 1)); + assertThrows(IllegalArgumentException.class, () -> ageInterpretation.get(null)); } @Test void modelUpdateTest() { - Relation person = new Relation<>("Person", 1, Boolean.class, false); - Relation age = new Relation("age", 1, Integer.class, null); - Relation friend = new Relation<>("friend", 2, Boolean.class, false); - - ModelStore store = new ModelStoreImpl(Set.of(person, age, friend)); - Model model = store.createModel(); - - model.put(person, Tuple.of(0), true); - model.put(person, Tuple.of(1), true); - model.put(age, Tuple.of(0), 3); - model.put(age, Tuple.of(1), 1); - model.put(friend, Tuple.of(0, 1), true); - model.put(friend, Tuple.of(1, 0), true); - - assertEquals(3, model.get(age, Tuple.of(0))); - assertTrue(model.get(friend, Tuple.of(0, 1))); - - model.put(age, Tuple.of(0), 4); - model.put(friend, Tuple.of(0, 1), false); - - assertEquals(4, model.get(age, Tuple.of(0))); - assertFalse(model.get(friend, Tuple.of(0, 1))); + var person = new Symbol<>("Person", 1, Boolean.class, false); + var age = new Symbol<>("age", 1, Integer.class, null); + var friend = new Symbol<>("friend", 2, Boolean.class, false); + + var store = ModelStore.builder().symbols(person, age, friend).build(); + var model = store.createModel(); + var personInterpretation = model.getInterpretation(person); + var ageInterpretation = model.getInterpretation(age); + var friendInterpretation = model.getInterpretation(friend); + + personInterpretation.put(Tuple.of(0), true); + personInterpretation.put(Tuple.of(1), true); + ageInterpretation.put(Tuple.of(0), 3); + ageInterpretation.put(Tuple.of(1), 1); + friendInterpretation.put(Tuple.of(0, 1), true); + friendInterpretation.put(Tuple.of(1, 0), true); + + assertEquals(3, ageInterpretation.get(Tuple.of(0))); + assertTrue(friendInterpretation.get(Tuple.of(0, 1))); + + ageInterpretation.put(Tuple.of(0), 4); + friendInterpretation.put(Tuple.of(0, 1), false); + + assertEquals(4, ageInterpretation.get(Tuple.of(0))); + assertFalse(friendInterpretation.get(Tuple.of(0, 1))); } @Test void restoreTest() { - Relation person = new Relation("Person", 1, Boolean.class, false); - Relation friend = new Relation("friend", 2, Boolean.class, false); - - ModelStore store = new ModelStoreImpl(Set.of(person, friend)); - Model model = store.createModel(); - - model.put(person, Tuple.of(0), true); - model.put(person, Tuple.of(1), true); - model.put(friend, Tuple.of(0, 1), true); - model.put(friend, Tuple.of(1, 0), true); + var person = new Symbol<>("Person", 1, Boolean.class, false); + var friend = new Symbol<>("friend", 2, Boolean.class, false); + + var store = ModelStore.builder().symbols(person, friend).build(); + var model = store.createModel(); + var personInterpretation = model.getInterpretation(person); + var friendInterpretation = model.getInterpretation(friend); + + personInterpretation.put(Tuple.of(0), true); + personInterpretation.put(Tuple.of(1), true); + friendInterpretation.put(Tuple.of(0, 1), true); + friendInterpretation.put(Tuple.of(1, 0), true); long state1 = model.commit(); - assertFalse(model.get(person, Tuple.of(2))); - assertFalse(model.get(friend, Tuple.of(0, 2))); + assertFalse(personInterpretation.get(Tuple.of(2))); + assertFalse(friendInterpretation.get(Tuple.of(0, 2))); - model.put(person, Tuple.of(2), true); - model.put(friend, Tuple.of(0, 2), true); + personInterpretation.put(Tuple.of(2), true); + friendInterpretation.put(Tuple.of(0, 2), true); long state2 = model.commit(); - assertTrue(model.get(person, Tuple.of(2))); - assertTrue(model.get(friend, Tuple.of(0, 2))); + assertTrue(personInterpretation.get(Tuple.of(2))); + assertTrue(friendInterpretation.get(Tuple.of(0, 2))); model.restore(state1); - assertFalse(model.get(person, Tuple.of(2))); - assertFalse(model.get(friend, Tuple.of(0, 2))); + assertFalse(personInterpretation.get(Tuple.of(2))); + assertFalse(friendInterpretation.get(Tuple.of(0, 2))); model.restore(state2); - assertTrue(model.get(person, Tuple.of(2))); - assertTrue(model.get(friend, Tuple.of(0, 2))); + assertTrue(personInterpretation.get(Tuple.of(2))); + assertTrue(friendInterpretation.get(Tuple.of(0, 2))); } } diff --git a/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalTest.java new file mode 100644 index 00000000..96fdc49e --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalTest.java @@ -0,0 +1,123 @@ +package tools.refinery.store.representation.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.representation.cardinality.CardinalityInterval; + +import java.util.stream.Stream; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; +import static tools.refinery.store.representation.cardinality.CardinalityIntervals.*; + +class CardinalityIntervalTest { + @ParameterizedTest(name = "min({0}, {1}) == {2}") + @MethodSource + void minTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { + assertThat(a.min(b), equalTo(expected)); + } + + static Stream minTest() { + return Stream.of( + Arguments.of(atMost(1), atMost(1), atMost(1)), + Arguments.of(atMost(1), between(2, 3), atMost(1)), + Arguments.of(atMost(1), atLeast(2), atMost(1)), + Arguments.of(atMost(1), ERROR, ERROR), + Arguments.of(atLeast(1), atLeast(2), atLeast(1)), + Arguments.of(atLeast(1), ERROR, ERROR), + Arguments.of(ERROR, atLeast(2), ERROR), + Arguments.of(ERROR, ERROR, ERROR) + ); + } + + @ParameterizedTest(name = "max({0}, {1}) == {2}") + @MethodSource + void maxTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { + assertThat(a.max(b), equalTo(expected)); + } + + static Stream maxTest() { + return Stream.of( + Arguments.of(atMost(1), atMost(1), atMost(1)), + Arguments.of(atMost(1), between(2, 3), between(2, 3)), + Arguments.of(atMost(1), atLeast(2), atLeast(2)), + Arguments.of(atMost(1), ERROR, ERROR), + Arguments.of(atLeast(1), atLeast(2), atLeast(2)), + Arguments.of(atLeast(1), ERROR, ERROR), + Arguments.of(ERROR, atLeast(2), ERROR), + Arguments.of(ERROR, ERROR, ERROR) + ); + } + + @ParameterizedTest(name = "{0} + {1} == {2}") + @MethodSource + void addTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { + assertThat(a.add(b), equalTo(expected)); + } + + static Stream addTest() { + return Stream.of( + Arguments.of(atMost(1), atMost(1), atMost(2)), + Arguments.of(atMost(1), between(2, 3), between(2, 4)), + Arguments.of(atMost(1), atLeast(2), atLeast(2)), + Arguments.of(atMost(1), ERROR, ERROR), + Arguments.of(atLeast(1), atLeast(2), atLeast(3)), + Arguments.of(atLeast(1), ERROR, ERROR), + Arguments.of(ERROR, atLeast(2), ERROR), + Arguments.of(ERROR, ERROR, ERROR) + ); + } + + @ParameterizedTest(name = "{0} * {1} == {2}") + @MethodSource + void multiplyTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { + assertThat(a.multiply(b), equalTo(expected)); + } + + static Stream multiplyTest() { + return Stream.of( + Arguments.of(between(2, 3), between(4, 5), between(8, 15)), + Arguments.of(atLeast(2), between(4, 5), atLeast(8)), + Arguments.of(between(2, 3), atLeast(4), atLeast(8)), + Arguments.of(between(2, 3), ERROR, ERROR), + Arguments.of(ERROR, between(4, 5), ERROR), + Arguments.of(ERROR, ERROR, ERROR) + ); + } + + @ParameterizedTest(name = "{0} /\\ {1} == {2}") + @MethodSource + void meetTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { + assertThat(a.meet(b), equalTo(expected)); + } + + static Stream meetTest() { + return Stream.of( + Arguments.of(atMost(1), atMost(2), atMost(1)), + Arguments.of(atMost(2), between(1, 3), between(1, 2)), + Arguments.of(atMost(1), between(1, 3), exactly(1)), + Arguments.of(atMost(1), between(2, 3), ERROR), + Arguments.of(atMost(1), ERROR, ERROR), + Arguments.of(ERROR, atMost(1), ERROR), + Arguments.of(ERROR, ERROR, ERROR) + ); + } + + @ParameterizedTest(name = "{0} \\/ {1} == {2}") + @MethodSource + void joinTest(CardinalityInterval a, CardinalityInterval b, CardinalityInterval expected) { + assertThat(a.join(b), equalTo(expected)); + } + + static Stream joinTest() { + return Stream.of( + Arguments.of(atMost(1), atMost(2), atMost(2)), + Arguments.of(atMost(2), between(1, 3), atMost(3)), + Arguments.of(atMost(1), between(2, 3), atMost(3)), + Arguments.of(atMost(1), ERROR, atMost(1)), + Arguments.of(ERROR, atMost(1), atMost(1)), + Arguments.of(ERROR, ERROR, ERROR) + ); + } +} diff --git a/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalsTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalsTest.java new file mode 100644 index 00000000..4a9ef8da --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalsTest.java @@ -0,0 +1,23 @@ +package tools.refinery.store.representation.cardinality; + +import org.junit.jupiter.api.Test; +import tools.refinery.store.representation.cardinality.CardinalityIntervals; +import tools.refinery.store.representation.cardinality.UpperCardinalities; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; + +class CardinalityIntervalsTest { + @Test + void betweenEmptyTest() { + var interval = CardinalityIntervals.between(2, 1); + assertThat(interval.isEmpty(), equalTo(true)); + } + + @Test + void betweenNegativeUpperBoundTest() { + var interval = CardinalityIntervals.between(0, -1); + assertThat(interval.upperBound(), equalTo(UpperCardinalities.UNBOUNDED)); + assertThat(interval.isEmpty(), equalTo(false)); + } +} diff --git a/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/EmptyCardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/EmptyCardinalityIntervalTest.java new file mode 100644 index 00000000..e8b77b9f --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/EmptyCardinalityIntervalTest.java @@ -0,0 +1,15 @@ +package tools.refinery.store.representation.cardinality; + +import org.junit.jupiter.api.Test; +import tools.refinery.store.representation.cardinality.CardinalityIntervals; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.lessThan; + +class EmptyCardinalityIntervalTest { + @Test + void inconsistentBoundsTest() { + assertThat(CardinalityIntervals.ERROR.upperBound().compareToInt(CardinalityIntervals.ERROR.lowerBound()), + lessThan(0)); + } +} diff --git a/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteCardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteCardinalityIntervalTest.java new file mode 100644 index 00000000..9a190818 --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteCardinalityIntervalTest.java @@ -0,0 +1,23 @@ +package tools.refinery.store.representation.cardinality; + +import org.junit.jupiter.api.Test; +import tools.refinery.store.representation.cardinality.NonEmptyCardinalityInterval; +import tools.refinery.store.representation.cardinality.UpperCardinalities; +import tools.refinery.store.representation.cardinality.UpperCardinality; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +class FiniteCardinalityIntervalTest { + @Test + void invalidLowerBoundConstructorTest() { + assertThrows(IllegalArgumentException.class, () -> new NonEmptyCardinalityInterval(-1, + UpperCardinalities.UNBOUNDED)); + } + + @Test + void invalidUpperBoundConstructorTest() { + var upperCardinality = UpperCardinality.of(1); + assertThrows(IllegalArgumentException.class, () -> new NonEmptyCardinalityInterval(2, + upperCardinality)); + } +} diff --git a/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinalityTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinalityTest.java new file mode 100644 index 00000000..90c21759 --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinalityTest.java @@ -0,0 +1,13 @@ +package tools.refinery.store.representation.cardinality; + +import org.junit.jupiter.api.Test; +import tools.refinery.store.representation.cardinality.FiniteUpperCardinality; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +class FiniteUpperCardinalityTest { + @Test + void invalidConstructorTest() { + assertThrows(IllegalArgumentException.class, () -> new FiniteUpperCardinality(-1)); + } +} diff --git a/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalitiesTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalitiesTest.java new file mode 100644 index 00000000..3c7c0320 --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalitiesTest.java @@ -0,0 +1,28 @@ +package tools.refinery.store.representation.cardinality; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import tools.refinery.store.representation.cardinality.FiniteUpperCardinality; +import tools.refinery.store.representation.cardinality.UnboundedUpperCardinality; +import tools.refinery.store.representation.cardinality.UpperCardinalities; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.instanceOf; + +class UpperCardinalitiesTest { + @ParameterizedTest + @ValueSource(ints = {0, 1, 255, 256, 1000, Integer.MAX_VALUE}) + void valueOfBoundedTest(int value) { + var upperCardinality = UpperCardinalities.valueOf(value); + assertThat(upperCardinality, instanceOf(FiniteUpperCardinality.class)); + assertThat(((FiniteUpperCardinality) upperCardinality).finiteUpperBound(), equalTo(value)); + } + + @Test + void valueOfUnboundedTest() { + var upperCardinality = UpperCardinalities.valueOf(-1); + assertThat(upperCardinality, instanceOf(UnboundedUpperCardinality.class)); + } +} diff --git a/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalityTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalityTest.java new file mode 100644 index 00000000..e87ce29b --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalityTest.java @@ -0,0 +1,112 @@ +package tools.refinery.store.representation.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.representation.cardinality.UpperCardinalities; +import tools.refinery.store.representation.cardinality.UpperCardinality; + +import java.util.stream.Stream; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; + +class UpperCardinalityTest { + @ParameterizedTest(name = "min({0}, {1}) == {2}") + @MethodSource + void minTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { + assertThat(a.min(b), equalTo(expected)); + } + + static Stream minTest() { + return Stream.of( + Arguments.of(UpperCardinality.of(0), UpperCardinality.of(0), UpperCardinality.of(0)), + Arguments.of(UpperCardinality.of(0), UpperCardinality.of(1), UpperCardinality.of(0)), + Arguments.of(UpperCardinality.of(1), UpperCardinality.of(0), UpperCardinality.of(0)), + Arguments.of(UpperCardinality.of(0), UpperCardinalities.UNBOUNDED, UpperCardinality.of(0)), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(0), UpperCardinality.of(0)), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) + ); + } + + @ParameterizedTest(name = "max({0}, {1}) == {2}") + @MethodSource + void maxTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { + assertThat(a.max(b), equalTo(expected)); + } + + static Stream maxTest() { + return Stream.of( + Arguments.of(UpperCardinality.of(0), UpperCardinality.of(0), UpperCardinality.of(0)), + Arguments.of(UpperCardinality.of(0), UpperCardinality.of(1), UpperCardinality.of(1)), + Arguments.of(UpperCardinality.of(1), UpperCardinality.of(0), UpperCardinality.of(1)), + Arguments.of(UpperCardinality.of(0), UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(0), UpperCardinalities.UNBOUNDED), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) + ); + } + + @ParameterizedTest(name = "{0} + {1} == {2}") + @MethodSource + void addTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { + assertThat(a.add(b), equalTo(expected)); + } + + static Stream addTest() { + return Stream.of( + Arguments.of(UpperCardinality.of(2), UpperCardinality.of(3), UpperCardinality.of(5)), + Arguments.of(UpperCardinality.of(2), UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(2), UpperCardinalities.UNBOUNDED), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) + ); + } + + @ParameterizedTest(name = "{0} * {1} == {2}") + @MethodSource + void multiplyTest(UpperCardinality a, UpperCardinality b, UpperCardinality expected) { + assertThat(a.multiply(b), equalTo(expected)); + } + + static Stream multiplyTest() { + return Stream.of( + Arguments.of(UpperCardinality.of(2), UpperCardinality.of(3), UpperCardinality.of(6)), + Arguments.of(UpperCardinality.of(2), UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(2), UpperCardinalities.UNBOUNDED), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED) + ); + } + + @ParameterizedTest(name = "{0}.compareTo({1}) == {2}") + @MethodSource + void compareToTest(UpperCardinality a, UpperCardinality b, int expected) { + assertThat(a.compareTo(b), equalTo(expected)); + } + + static Stream compareToTest() { + return Stream.of( + Arguments.of(UpperCardinality.of(0), UpperCardinality.of(0), 0), + Arguments.of(UpperCardinality.of(0), UpperCardinality.of(1), -1), + Arguments.of(UpperCardinality.of(1), UpperCardinality.of(0), 1), + Arguments.of(UpperCardinality.of(0), UpperCardinalities.UNBOUNDED, -1), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinality.of(0), 1), + Arguments.of(UpperCardinalities.UNBOUNDED, UpperCardinalities.UNBOUNDED, 0) + ); + } + + @ParameterizedTest(name = "{0}.compareToInt({1}) == {2}") + @MethodSource + void compareToIntTest(UpperCardinality a, int b, int expected) { + assertThat(a.compareToInt(b), equalTo(expected)); + } + + static Stream compareToIntTest() { + return Stream.of( + Arguments.of(UpperCardinality.of(3), -1, 1), + Arguments.of(UpperCardinality.of(3), 2, 1), + Arguments.of(UpperCardinality.of(3), 3, 0), + Arguments.of(UpperCardinality.of(3), 4, -1), + Arguments.of(UpperCardinalities.UNBOUNDED, -1, 1), + Arguments.of(UpperCardinalities.UNBOUNDED, 3, 1) + ); + } +} -- cgit v1.2.3-54-g00ecf